scribe-cms 0.0.17 → 0.0.21

package/dist/index.cjs

@@ -2,8 +2,8 @@
 
 var zod = require('zod');
 var path3 = require('path');
-var fs2 = require('fs');
-var matter = require('gray-matter');
+var fs14 = require('fs');
+var matter4 = require('gray-matter');
 var Database = require('better-sqlite3');
 var remarkMdx = require('remark-mdx');
 var remarkParse = require('remark-parse');
@@ -15,8 +15,8 @@ var genai = require('@google/genai');
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var path3__default = /*#__PURE__*/_interopDefault(path3);
-var fs2__default = /*#__PURE__*/_interopDefault(fs2);
-var matter__default = /*#__PURE__*/_interopDefault(matter);
+var fs14__default = /*#__PURE__*/_interopDefault(fs14);
+var matter4__default = /*#__PURE__*/_interopDefault(matter4);
 var Database__default = /*#__PURE__*/_interopDefault(Database);
 var remarkMdx__default = /*#__PURE__*/_interopDefault(remarkMdx);
 var remarkParse__default = /*#__PURE__*/_interopDefault(remarkParse);
@@ -26,6 +26,7 @@ var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${_
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 var FIELD_KIND = /* @__PURE__ */ Symbol.for("@genlook/scribe/fieldKind");
 var RELATION_META = /* @__PURE__ */ Symbol.for("@genlook/scribe/relationMeta");
+var ASSET_META = /* @__PURE__ */ Symbol.for("@genlook/scribe/assetMeta");
 function getFieldKind(schema) {
   const tagged = schema;
   return tagged[FIELD_KIND] ?? "structural";
@@ -53,6 +54,29 @@ function getRelationTarget(schema) {
   }
   return null;
 }
+function getAssetMeta(schema) {
+  let current = schema;
+  for (let i = 0; i < 8; i++) {
+    const tagged = current;
+    if (tagged[ASSET_META]) {
+      return tagged[ASSET_META];
+    }
+    if (typeof tagged.unwrap === "function") {
+      current = tagged.unwrap();
+      continue;
+    }
+    if (typeof tagged.removeDefault === "function") {
+      current = tagged.removeDefault();
+      continue;
+    }
+    if (tagged._def?.innerType) {
+      current = tagged._def.innerType;
+      continue;
+    }
+    break;
+  }
+  return null;
+}
 function mark(schema, kind) {
   Object.defineProperty(schema, FIELD_KIND, {
     value: kind,
@@ -69,6 +93,14 @@ function markRelation(schema, meta) {
   });
   return mark(schema, "structural");
 }
+function markAsset(schema, meta) {
+  Object.defineProperty(schema, ASSET_META, {
+    value: meta,
+    enumerable: false,
+    configurable: true
+  });
+  return mark(schema, "structural");
+}
 var field = {
   translatable: (schema) => mark(schema, "translatable"),
   structural: (schema) => mark(schema, "structural"),
@@ -89,9 +121,24 @@ var field = {
     } else {
       inner = zod.z.string().min(1);
     }
-    markRelation(inner, { typeId, multiple, optional });
+    const onTargetDelete = options?.onTargetDelete ?? "restrict";
+    markRelation(inner, { typeId, multiple, optional, onTargetDelete });
     const schema = optional ? inner.optional() : inner;
     return schema;
+  },
+  asset: (options) => {
+    const optional = options?.optional ?? false;
+    const inner = zod.z.string().min(1);
+    markAsset(inner, {
+      dir: options?.dir,
+      template: options?.template,
+      formats: options?.formats,
+      maxKB: options?.maxKB,
+      optional,
+      onDelete: options?.onDelete ?? "delete"
+    });
+    const schema = optional || options?.template !== void 0 ? inner.optional() : inner;
+    return schema;
   }
 };
 function unwrapSchema(schema) {
@@ -131,6 +178,208 @@ function peelOptionalWrappers(schema) {
   return current;
 }
 
+// src/core/introspect-schema.ts
+function getArrayElement(schema) {
+  if (schema instanceof Object && "element" in schema && schema._def?.type === "array") {
+    return schema.element;
+  }
+  return null;
+}
+function introspectSchema(schema, prefix = []) {
+  const relation = getRelationTarget(schema);
+  if (relation && prefix.length > 0) {
+    return [
+      {
+        path: prefix,
+        kind: "relation",
+        relationTarget: relation.typeId,
+        relationMultiple: relation.multiple,
+        relationOptional: relation.optional,
+        relationOnTargetDelete: relation.onTargetDelete
+      }
+    ];
+  }
+  const asset = getAssetMeta(schema);
+  if (asset && prefix.length > 0) {
+    return [
+      {
+        path: prefix,
+        kind: "asset",
+        assetDir: asset.dir,
+        assetTemplate: asset.template,
+        assetFormats: asset.formats,
+        assetMaxKB: asset.maxKB,
+        assetOptional: asset.optional,
+        assetOnDelete: asset.onDelete
+      }
+    ];
+  }
+  if (prefix.length > 0 && getFieldKind(schema) === "translatable") {
+    return [{ path: prefix, kind: "translatable" }];
+  }
+  const base = peelOptionalWrappers(schema);
+  if (base instanceof Object && "shape" in base) {
+    const shape = base.shape;
+    const fields = [];
+    for (const [key, child] of Object.entries(shape)) {
+      fields.push(...introspectSchema(child, [...prefix, key]));
+    }
+    return fields;
+  }
+  const element = getArrayElement(base);
+  if (element) {
+    const elementBase = peelOptionalWrappers(element);
+    if (elementBase instanceof Object && "shape" in elementBase) {
+      const shape = elementBase.shape;
+      const fields = [];
+      for (const [key, child] of Object.entries(shape)) {
+        fields.push(...introspectSchema(child, [...prefix, "*", key]));
+      }
+      return fields;
+    }
+  }
+  return [{ path: prefix, kind: getFieldKind(schema) }];
+}
+function buildPathTrie(paths) {
+  const root = { leaf: false, children: /* @__PURE__ */ new Map() };
+  for (const path15 of paths) {
+    let node = root;
+    for (const segment of path15) {
+      let child = node.children.get(segment);
+      if (!child) {
+        child = { leaf: false, children: /* @__PURE__ */ new Map() };
+        node.children.set(segment, child);
+      }
+      node = child;
+    }
+    node.leaf = true;
+  }
+  return root;
+}
+function extractNode(data, trie) {
+  if (trie.leaf) return data;
+  const star = trie.children.get("*");
+  if (star) {
+    if (!Array.isArray(data)) return void 0;
+    return data.map(
+      (item) => typeof item === "object" && item !== null ? extractNode(item, star) ?? {} : {}
+    );
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return void 0;
+  const record = data;
+  const out = {};
+  let any = false;
+  for (const [key, child] of trie.children) {
+    const value = extractNode(record[key], child);
+    if (value !== void 0) {
+      out[key] = value;
+      any = true;
+    }
+  }
+  return any ? out : void 0;
+}
+function extractByPaths(data, paths) {
+  if (paths.length === 0) return {};
+  const extracted = extractNode(data, buildPathTrie(paths));
+  return extracted && typeof extracted === "object" && !Array.isArray(extracted) ? extracted : {};
+}
+function pickTranslatable(data, schema) {
+  const translatablePaths = introspectSchema(schema).filter((f) => f.kind === "translatable").map((f) => f.path);
+  return extractByPaths(data, translatablePaths);
+}
+function pruneOrphanNestedTranslations(localeData, enData, schema) {
+  const out = { ...localeData };
+  const structuralParentsWithNested = /* @__PURE__ */ new Set();
+  for (const meta of introspectSchema(schema)) {
+    if (meta.kind !== "translatable" || meta.path.length < 3 || meta.path[1] !== "*") continue;
+    structuralParentsWithNested.add(meta.path[0]);
+  }
+  for (const parent of structuralParentsWithNested) {
+    const enParent = enData[parent];
+    if (enParent === void 0 || enParent === null) {
+      delete out[parent];
+    }
+  }
+  return out;
+}
+function pickStructural(data, schema) {
+  const structuralPaths = introspectSchema(schema).filter((f) => f.kind === "structural" || f.kind === "relation" || f.kind === "asset").map((f) => f.path);
+  return extractByPaths(data, structuralPaths);
+}
+function mergeStructuralOntoLocale(localeData, enData, schema) {
+  const structural = pickStructural(enData, schema);
+  const translatable = pickTranslatable(localeData, schema);
+  return deepMerge(structural, translatable);
+}
+function deepMerge(base, overlay) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(overlay)) {
+    if (value && typeof value === "object" && !Array.isArray(value) && out[key] && typeof out[key] === "object" && !Array.isArray(out[key])) {
+      out[key] = deepMerge(out[key], value);
+    } else if (Array.isArray(value) && Array.isArray(out[key])) {
+      out[key] = mergeArrayOverlay(out[key], value);
+    } else if (value !== void 0) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function mergeArrayOverlay(base, overlay) {
+  return base.map((item, index) => {
+    const overlayItem = overlay[index];
+    if (item && typeof item === "object" && !Array.isArray(item) && overlayItem && typeof overlayItem === "object" && !Array.isArray(overlayItem)) {
+      return deepMerge(item, overlayItem);
+    }
+    return overlayItem ?? item;
+  });
+}
+function listTranslatableFields(schema) {
+  return introspectSchema(schema).filter((f) => f.kind === "translatable");
+}
+function isTypeTranslatable(type) {
+  return listTranslatableFields(type.schema).length > 0 || type.body !== false;
+}
+function listRelationFields(schema) {
+  return introspectSchema(schema).filter((f) => f.kind === "relation");
+}
+function listAssetFields(schema) {
+  return introspectSchema(schema).filter((f) => f.kind === "asset");
+}
+
+// src/core/managed-roots.ts
+function normalizeRoot(root) {
+  const trimmed = `/${root.replace(/^\/+|\/+$/g, "")}`;
+  return trimmed === "/" ? "" : trimmed;
+}
+function templateManagedRoot(template) {
+  const braceIndex = template.indexOf("{");
+  const staticPart = braceIndex >= 0 ? template.slice(0, braceIndex) : template;
+  const lastSlash = staticPart.lastIndexOf("/");
+  const prefix = lastSlash >= 0 ? staticPart.slice(0, lastSlash) : staticPart;
+  return normalizeRoot(prefix);
+}
+function getManagedRoots(config) {
+  if (!config.assets) return [];
+  const roots = /* @__PURE__ */ new Set();
+  for (const dir of config.assets.managedDirs ?? []) {
+    const normalized = normalizeRoot(dir);
+    if (normalized) roots.add(normalized);
+  }
+  for (const type of config.types) {
+    for (const f of listAssetFields(type.schema)) {
+      if (f.assetDir) {
+        const normalized = normalizeRoot(f.assetDir);
+        if (normalized) roots.add(normalized);
+      }
+      if (f.assetTemplate) {
+        const normalized = templateManagedRoot(f.assetTemplate);
+        if (normalized) roots.add(normalized);
+      }
+    }
+  }
+  return [...roots].sort();
+}
+
 // src/core/types.ts
 function defineConfig(config) {
   return config;
@@ -144,14 +393,14 @@ var SLUG_PLACEHOLDER = "{slug}";
 function isRoutableType(type) {
   return typeof type.path === "string" && type.path.length > 0;
 }
-function assertValidPathTemplate(path13, typeId) {
-  if (!path13.startsWith("/")) {
-    throw new Error(`Content type "${typeId}": path must start with / (got "${path13}")`);
+function assertValidPathTemplate(path15, typeId) {
+  if (!path15.startsWith("/")) {
+    throw new Error(`Content type "${typeId}": path must start with / (got "${path15}")`);
   }
-  const count = (path13.match(/\{slug\}/g) ?? []).length;
+  const count = (path15.match(/\{slug\}/g) ?? []).length;
   if (count !== 1) {
     throw new Error(
-      `Content type "${typeId}": path must contain exactly one {slug} (got "${path13}")`
+      `Content type "${typeId}": path must contain exactly one {slug} (got "${path15}")`
     );
   }
 }
@@ -261,7 +510,15 @@ function resolveConfig(input, baseDir) {
   const projectRoot = path3__default.default.resolve(baseDir ?? process.cwd(), raw.rootDir);
   const contentRoot = path3__default.default.resolve(projectRoot, raw.contentDir ?? "content");
   const storePath = path3__default.default.resolve(projectRoot, raw.store ?? ".scribe/store.sqlite");
-  const assetsPath = raw.assetsDir ? path3__default.default.resolve(projectRoot, raw.assetsDir) : void 0;
+  let assetsPath;
+  let assets;
+  if (raw.assets !== void 0 || raw.assetsDir !== void 0) {
+    const dir = raw.assets?.dir ?? raw.assetsDir ?? "public";
+    const publicPath = raw.assets?.publicPath ?? "/";
+    const managedDirs = raw.assets?.managedDirs ?? [];
+    assetsPath = path3__default.default.resolve(projectRoot, dir);
+    assets = { assetsPath, publicPath, managedDirs };
+  }
   const seenIds = /* @__PURE__ */ new Set();
   const types = raw.types.map((type) => {
     if (seenIds.has(type.id)) {
@@ -276,13 +533,17 @@ function resolveConfig(input, baseDir) {
       contentDir: type.contentDir ?? type.id,
       label: type.label ?? type.id.charAt(0).toUpperCase() + type.id.slice(1),
       slugStrategy: type.slugStrategy ?? "fixed",
-      indexFallback: type.indexFallback ?? (type.path ? "en" : "none")
+      indexFallback: type.indexFallback ?? (type.path ? "en" : "none"),
+      // `body` defaults to true (fully backwards compatible). A resolved type
+      // always carries an explicit boolean so consumers read one source of truth.
+      body: type.body ?? true
     };
   });
   const config = {
     rootDir: contentRoot,
     storePath,
     assetsPath,
+    assets,
     locales: [...raw.locales],
     defaultLocale,
     localeRouting,
@@ -316,134 +577,6 @@ function deriveLocaleFallbacks(locales, defaultLocale) {
   }
   return fallbacks;
 }
-
-// src/core/introspect-schema.ts
-function getArrayElement(schema) {
-  if (schema instanceof Object && "element" in schema && schema._def?.type === "array") {
-    return schema.element;
-  }
-  return null;
-}
-function introspectSchema(schema, prefix = []) {
-  const relation = getRelationTarget(schema);
-  if (relation && prefix.length > 0) {
-    return [
-      {
-        path: prefix,
-        kind: "relation",
-        relationTarget: relation.typeId,
-        relationMultiple: relation.multiple,
-        relationOptional: relation.optional
-      }
-    ];
-  }
-  if (prefix.length > 0 && getFieldKind(schema) === "translatable") {
-    return [{ path: prefix, kind: "translatable" }];
-  }
-  const base = peelOptionalWrappers(schema);
-  if (base instanceof Object && "shape" in base) {
-    const shape = base.shape;
-    const fields = [];
-    for (const [key, child] of Object.entries(shape)) {
-      fields.push(...introspectSchema(child, [...prefix, key]));
-    }
-    return fields;
-  }
-  const element = getArrayElement(base);
-  if (element) {
-    const elementBase = peelOptionalWrappers(element);
-    if (elementBase instanceof Object && "shape" in elementBase) {
-      const shape = elementBase.shape;
-      const fields = [];
-      for (const [key, child] of Object.entries(shape)) {
-        fields.push(...introspectSchema(child, [...prefix, "*", key]));
-      }
-      return fields;
-    }
-  }
-  return [{ path: prefix, kind: getFieldKind(schema) }];
-}
-function buildPathTrie(paths) {
-  const root = { leaf: false, children: /* @__PURE__ */ new Map() };
-  for (const path13 of paths) {
-    let node = root;
-    for (const segment of path13) {
-      let child = node.children.get(segment);
-      if (!child) {
-        child = { leaf: false, children: /* @__PURE__ */ new Map() };
-        node.children.set(segment, child);
-      }
-      node = child;
-    }
-    node.leaf = true;
-  }
-  return root;
-}
-function extractNode(data, trie) {
-  if (trie.leaf) return data;
-  const star = trie.children.get("*");
-  if (star) {
-    if (!Array.isArray(data)) return void 0;
-    return data.map(
-      (item) => typeof item === "object" && item !== null ? extractNode(item, star) ?? {} : {}
-    );
-  }
-  if (typeof data !== "object" || data === null || Array.isArray(data)) return void 0;
-  const record = data;
-  const out = {};
-  let any = false;
-  for (const [key, child] of trie.children) {
-    const value = extractNode(record[key], child);
-    if (value !== void 0) {
-      out[key] = value;
-      any = true;
-    }
-  }
-  return any ? out : void 0;
-}
-function extractByPaths(data, paths) {
-  if (paths.length === 0) return {};
-  const extracted = extractNode(data, buildPathTrie(paths));
-  return extracted && typeof extracted === "object" && !Array.isArray(extracted) ? extracted : {};
-}
-function pickTranslatable(data, schema) {
-  const translatablePaths = introspectSchema(schema).filter((f) => f.kind === "translatable").map((f) => f.path);
-  return extractByPaths(data, translatablePaths);
-}
-function pickStructural(data, schema) {
-  const structuralPaths = introspectSchema(schema).filter((f) => f.kind === "structural" || f.kind === "relation").map((f) => f.path);
-  return extractByPaths(data, structuralPaths);
-}
-function mergeStructuralOntoLocale(localeData, enData, schema) {
-  const structural = pickStructural(enData, schema);
-  const translatable = pickTranslatable(localeData, schema);
-  return deepMerge(structural, translatable);
-}
-function deepMerge(base, overlay) {
-  const out = { ...base };
-  for (const [key, value] of Object.entries(overlay)) {
-    if (value && typeof value === "object" && !Array.isArray(value) && out[key] && typeof out[key] === "object" && !Array.isArray(out[key])) {
-      out[key] = deepMerge(out[key], value);
-    } else if (Array.isArray(value) && Array.isArray(out[key])) {
-      out[key] = mergeArrayOverlay(out[key], value);
-    } else {
-      out[key] = value;
-    }
-  }
-  return out;
-}
-function mergeArrayOverlay(base, overlay) {
-  return base.map((item, index) => {
-    const overlayItem = overlay[index];
-    if (item && typeof item === "object" && !Array.isArray(item) && overlayItem && typeof overlayItem === "object" && !Array.isArray(overlayItem)) {
-      return deepMerge(item, overlayItem);
-    }
-    return overlayItem ?? item;
-  });
-}
-function listRelationFields(schema) {
-  return introspectSchema(schema).filter((f) => f.kind === "relation");
-}
 var SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var slugPatternSchema = zod.z.string().regex(SLUG_PATTERN, "slug must be lowercase-kebab-case");
 var isoDateSchema = zod.z.string().regex(/^\d{4}-\d{2}-\d{2}(T[\d:.Z+-]*)?$/, "Use ISO date YYYY-MM-DD or full ISO 8601");
@@ -534,12 +667,18 @@ function extractBuiltinEnFields(data, _pathTemplate, _enSlug, _defaultLocale) {
       delete rest[internalKey];
     }
   }
+  let vars;
+  if (rest.vars !== void 0) {
+    vars = rest.vars;
+    delete rest.vars;
+  }
   return {
     builtin: {
       publishedAt,
       updatedAt,
       noindex,
-      canonicalPathOverride
+      canonicalPathOverride,
+      vars
     },
     rest,
     issues
@@ -578,6 +717,7 @@ function mergeBuiltinsIntoFrontmatter(frontmatter, doc, type, defaultLocale, loc
   if (doc.updatedAt !== void 0) out.updatedAt = doc.updatedAt;
   out.noindex = doc.noindex;
   out.canonicalPath = resolveCanonicalPathname(type, doc, defaultLocale, localeRouting);
+  if (doc.vars !== void 0) out.vars = doc.vars;
   return out;
 }
 function seoFieldsFromEn(enDoc) {
@@ -667,7 +807,7 @@ function resolveStorePath(config) {
 function openStore(config, mode = "readwrite") {
   const storePath = resolveStorePath(config);
   if (mode === "readwrite") {
-    fs2__default.default.mkdirSync(path3__default.default.dirname(storePath), { recursive: true });
+    fs14__default.default.mkdirSync(path3__default.default.dirname(storePath), { recursive: true });
   }
   const db = new Database__default.default(storePath, { readonly: mode === "readonly" });
   if (mode === "readwrite") {
@@ -767,6 +907,26 @@ function listTranslationsForEnSlug(db, contentType, enSlug) {
 function bulkLoadTranslations(db) {
   return db.prepare(`SELECT * FROM translations ORDER BY content_type, en_slug, locale`).all();
 }
+function countTranslationsForEnSlug(db, contentType, enSlug) {
+  const row = db.prepare(
+    `SELECT COUNT(*) as count FROM translations WHERE content_type = ? AND en_slug = ?`
+  ).get(contentType, enSlug);
+  return row.count;
+}
+function countEnSnapshotsForEnSlug(db, contentType, enSlug) {
+  const row = db.prepare(
+    `SELECT COUNT(*) as count FROM en_snapshots WHERE content_type = ? AND en_slug = ?`
+  ).get(contentType, enSlug);
+  return row.count;
+}
+function deleteTranslationsForEnSlug(db, contentType, enSlug) {
+  const info = db.prepare(`DELETE FROM translations WHERE content_type = ? AND en_slug = ?`).run(contentType, enSlug);
+  return info.changes;
+}
+function deleteEnSnapshotsForEnSlug(db, contentType, enSlug) {
+  const info = db.prepare(`DELETE FROM en_snapshots WHERE content_type = ? AND en_slug = ?`).run(contentType, enSlug);
+  return info.changes;
+}
 
 // src/translate/normalize-mdx-body.ts
 function needsMdxEscapeNormalization(body) {
@@ -900,6 +1060,317 @@ function assertValidTranslatedMdxBody(body) {
   return prepared;
 }
 
+// src/loader/resolve-assets.ts
+function joinPublicPath(publicPath, webPath) {
+  if (publicPath === "" || publicPath === "/") return webPath;
+  const suffix = webPath.startsWith("/") ? webPath : `/${webPath}`;
+  return publicPath.replace(/\/+$/, "") + suffix;
+}
+function materializeTemplate(template, enSlug) {
+  return template.split("{slug}").join(enSlug);
+}
+function setAssetAtPath(container, path15, transform) {
+  const [head, ...rest] = path15;
+  if (head === void 0) return;
+  if (rest.length === 0) {
+    const current = container[head];
+    const next = transform(typeof current === "string" ? current : void 0);
+    if (next !== void 0) container[head] = next;
+    return;
+  }
+  if (rest[0] === "*") {
+    const arr = container[head];
+    if (!Array.isArray(arr)) return;
+    for (const item of arr) {
+      if (item && typeof item === "object" && !Array.isArray(item)) {
+        setAssetAtPath(item, rest.slice(1), transform);
+      }
+    }
+    return;
+  }
+  const child = container[head];
+  if (child && typeof child === "object" && !Array.isArray(child)) {
+    setAssetAtPath(child, rest, transform);
+  }
+}
+function resolveDocumentAssets(doc, assetFields, assets) {
+  const frontmatter = doc.frontmatter;
+  for (const f of assetFields) {
+    setAssetAtPath(frontmatter, f.path, (current) => {
+      let value = current;
+      if (value === void 0) {
+        if (!f.assetTemplate) return void 0;
+        value = materializeTemplate(f.assetTemplate, doc.enSlug);
+      }
+      return joinPublicPath(assets.publicPath, value);
+    });
+  }
+}
+
+// src/inline/tokens.ts
+var TOKEN_OPEN = "${{";
+var ESCAPE_SEQUENCE = "$\\{{";
+var ESCAPE_RESULT = "${{";
+function placeholderMarker(n) {
+  return `%%${n}%%`;
+}
+function findTokenEnd(body, start) {
+  let i = start;
+  let inString = false;
+  while (i < body.length) {
+    const ch = body[i];
+    if (ch === "\n") return -1;
+    if (inString) {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === '"') inString = false;
+      i += 1;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      i += 1;
+      continue;
+    }
+    if (ch === "}" && body[i + 1] === "}") return i;
+    i += 1;
+  }
+  return -1;
+}
+function parseTokenInner(inner) {
+  const colon = inner.indexOf(":");
+  if (colon === -1) {
+    return { ok: false, reason: `missing kind separator ":"` };
+  }
+  const kind = inner.slice(0, colon);
+  const rest = inner.slice(colon + 1);
+  switch (kind) {
+    case "static": {
+      let text;
+      try {
+        text = JSON.parse(rest);
+      } catch {
+        return { ok: false, reason: `static value is not a valid JSON string` };
+      }
+      if (typeof text !== "string") {
+        return { ok: false, reason: `static value must be a JSON string` };
+      }
+      return { ok: true, token: { kind: "static", text } };
+    }
+    case "relation": {
+      const parts = rest.split(":");
+      if (parts.length !== 3) {
+        return {
+          ok: false,
+          reason: `relation must be relation:<typeId>:<enSlug>:href or relation:<typeId>:<enSlug>:slug`
+        };
+      }
+      const [targetTypeId, enSlug, mode] = parts;
+      if (!targetTypeId || !enSlug) {
+        return { ok: false, reason: `relation is missing a typeId or enSlug` };
+      }
+      if (mode !== "href" && mode !== "slug") {
+        return { ok: false, reason: `relation mode must be "href" or "slug" (got "${mode}")` };
+      }
+      return {
+        ok: true,
+        token: {
+          kind: "relation",
+          targetTypeId,
+          enSlug,
+          mode
+        }
+      };
+    }
+    case "asset": {
+      if (!rest.startsWith("/")) {
+        return { ok: false, reason: `asset path must start with "/" (got "${rest}")` };
+      }
+      return { ok: true, token: { kind: "asset", webPath: rest } };
+    }
+    case "var": {
+      if (!rest) return { ok: false, reason: `var is missing a key` };
+      return { ok: true, token: { kind: "var", key: rest } };
+    }
+    default:
+      return { ok: false, reason: `unknown token kind "${kind}"` };
+  }
+}
+function extractInlineTokens(body) {
+  const tokens = [];
+  const malformed = [];
+  let out = "";
+  let i = 0;
+  while (i < body.length) {
+    const open = body.indexOf(TOKEN_OPEN, i);
+    if (open === -1) {
+      out += body.slice(i);
+      break;
+    }
+    out += body.slice(i, open);
+    const contentStart = open + TOKEN_OPEN.length;
+    const end = findTokenEnd(body, contentStart);
+    if (end === -1) {
+      malformed.push({
+        raw: body.slice(open),
+        reason: `unterminated token (missing "}}")`,
+        index: open
+      });
+      out += body.slice(open);
+      break;
+    }
+    const raw = body.slice(open, end + 2);
+    const inner = body.slice(contentStart, end);
+    const parsed = parseTokenInner(inner);
+    if (parsed.ok) {
+      tokens.push({ ...parsed.token, raw });
+      out += placeholderMarker(tokens.length);
+    } else {
+      malformed.push({ raw, reason: parsed.reason, index: open });
+      out += raw;
+    }
+    i = end + 2;
+  }
+  return { placeholderBody: out, tokens, malformed };
+}
+function fillPlaceholders(body, resolvedValues) {
+  return body.replace(/%%(\d+)%%/g, (match, n) => {
+    const idx = Number(n) - 1;
+    return idx >= 0 && idx < resolvedValues.length ? resolvedValues[idx] : match;
+  });
+}
+function unescapeInlineTokens(body) {
+  return body.split(ESCAPE_SEQUENCE).join(ESCAPE_RESULT);
+}
+function countMarkerOccurrences(body, n) {
+  return body.split(placeholderMarker(n)).length - 1;
+}
+function replaceInlineSpans(body, opts) {
+  let out = "";
+  let i = 0;
+  while (i < body.length) {
+    if (body.startsWith(ESCAPE_SEQUENCE, i)) {
+      out += opts.escape();
+      i += ESCAPE_SEQUENCE.length;
+      continue;
+    }
+    if (body.startsWith(TOKEN_OPEN, i)) {
+      const end = findTokenEnd(body, i + TOKEN_OPEN.length);
+      if (end !== -1) {
+        const raw = body.slice(i, end + 2);
+        const inner = body.slice(i + TOKEN_OPEN.length, end);
+        out += opts.token(raw, inner);
+        i = end + 2;
+        continue;
+      }
+    }
+    out += body[i];
+    i += 1;
+  }
+  return out;
+}
+function maskInlineTokensForMdx(body) {
+  return replaceInlineSpans(body, {
+    token: () => "inline",
+    escape: () => "$"
+  });
+}
+
+// src/inline/resolve-tokens.ts
+function slugKey(typeId, enSlug, locale) {
+  return `${typeId}\0${enSlug}\0${locale}`;
+}
+function isStringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return Object.values(value).every((v) => typeof v === "string");
+}
+function createInlineResolver(config, options = {}) {
+  const linkStyle = options.linkStyle ?? "app";
+  const exportExtension = options.exportExtension ?? ".md";
+  const urlBuilder = createUrlBuilder(config);
+  const typeById = new Map(config.types.map((t) => [t.id, t]));
+  const storePath = resolveStorePath(config);
+  let slugCache = null;
+  const localizedSlugIndex = () => {
+    let mtime = 0;
+    try {
+      mtime = fs14__default.default.statSync(storePath).mtimeMs;
+    } catch {
+      mtime = 0;
+    }
+    if (slugCache && slugCache.mtime === mtime) return slugCache.index;
+    const index = /* @__PURE__ */ new Map();
+    try {
+      const db = openStore(config, "readonly");
+      try {
+        for (const row of bulkLoadTranslations(db)) {
+          index.set(slugKey(row.content_type, row.en_slug, row.locale), row.slug);
+        }
+      } finally {
+        db.close();
+      }
+    } catch {
+    }
+    slugCache = { mtime, index };
+    return index;
+  };
+  const localizedSlug2 = (typeId, enSlug, locale) => {
+    if (locale === config.defaultLocale) return enSlug;
+    const index = localizedSlugIndex();
+    const direct = index.get(slugKey(typeId, enSlug, locale));
+    if (direct) return direct;
+    for (const fb of config.localeFallbacks?.[locale] ?? []) {
+      const hit = index.get(slugKey(typeId, enSlug, fb));
+      if (hit) return hit;
+    }
+    return enSlug;
+  };
+  return {
+    resolve(token, enFrontmatter, locale) {
+      switch (token.kind) {
+        case "static":
+          return token.text;
+        case "var": {
+          const vars = enFrontmatter.vars;
+          if (isStringRecord(vars) && typeof vars[token.key] === "string") {
+            return vars[token.key];
+          }
+          return "";
+        }
+        case "asset": {
+          const assets = config.assets;
+          return assets ? joinPublicPath(assets.publicPath, token.webPath) : token.webPath;
+        }
+        case "relation": {
+          const type = typeById.get(token.targetTypeId);
+          if (!type) return "";
+          if (token.mode === "slug") return token.enSlug;
+          if (!isRoutableType(type)) return "";
+          const slug = localizedSlug2(token.targetTypeId, token.enSlug, locale);
+          if (linkStyle === "export") {
+            return urlBuilder.resolvePath(type.path, `${slug}${exportExtension}`, locale);
+          }
+          return type.path.replace("{slug}", slug);
+        }
+      }
+    }
+  };
+}
+function substituteEnInlineBody(rawBody, enFrontmatter, defaultLocale, resolver) {
+  const { placeholderBody, tokens } = extractInlineTokens(rawBody);
+  if (tokens.length === 0) return unescapeInlineTokens(placeholderBody);
+  const values = tokens.map((t) => resolver.resolve(t, enFrontmatter, defaultLocale));
+  return unescapeInlineTokens(fillPlaceholders(placeholderBody, values));
+}
+function fillTranslatedInlineBody(translatedBody, enRawBody, enFrontmatter, locale, resolver) {
+  const { tokens } = extractInlineTokens(enRawBody);
+  if (tokens.length === 0) return unescapeInlineTokens(translatedBody);
+  const values = tokens.map((t) => resolver.resolve(t, enFrontmatter, locale));
+  return unescapeInlineTokens(fillPlaceholders(translatedBody, values));
+}
+
 // src/loader/normalize-en.ts
 function normalizeEnFrontmatter(data) {
   const out = { ...data };
@@ -925,15 +1396,15 @@ function isPostFile(name) {
   return isPublishableContentFile(name);
 }
 function listEnFiles(contentDir) {
-  if (!fs2__default.default.existsSync(contentDir)) return [];
-  return fs2__default.default.readdirSync(contentDir).filter(isPostFile).map((f) => path3__default.default.join(contentDir, f));
+  if (!fs14__default.default.existsSync(contentDir)) return [];
+  return fs14__default.default.readdirSync(contentDir).filter(isPostFile).map((f) => path3__default.default.join(contentDir, f));
 }
 function slugFromPath(filePath) {
   return path3__default.default.basename(filePath).replace(/\.(md|mdx)$/, "");
 }
 function parseEnMdx(filePath, config, type) {
-  const raw = fs2__default.default.readFileSync(filePath, "utf8");
-  const parsed = matter__default.default(raw);
+  const raw = fs14__default.default.readFileSync(filePath, "utf8");
+  const parsed = matter4__default.default(raw);
   const slug = slugFromPath(filePath);
   const normalized = normalizeEnFrontmatter(parsed.data);
   const { builtin, rest, issues: builtinIssues } = extractBuiltinEnFields(
@@ -971,6 +1442,7 @@ function parseEnMdx(filePath, config, type) {
       updatedAt: builtin.updatedAt,
       noindex: builtin.noindex,
       canonicalPathOverride: builtin.canonicalPathOverride,
+      vars: builtin.vars,
       slug,
       locale: config.defaultLocale
     },
@@ -995,12 +1467,15 @@ function parseEnMdx(filePath, config, type) {
     noindex: builtin.noindex,
     canonicalPathOverride: builtin.canonicalPathOverride,
     frontmatter,
-    content: parsed.content,
+    // Bodyless types (`body: false`) never carry a body: the loader skips the
+    // MDX body entirely so runtimes, exports, and hashing all see an empty body.
+    // A stray body is reported separately by `scribe validate`.
+    content: type.body === false ? "" : parsed.content,
     filePath
   };
   return { document: document2, issues };
 }
-function buildDocumentFromTranslation(row, enDoc, type, config) {
+function buildDocumentFromTranslation(row, enDoc, type, config, inlineResolver) {
   const localeFm = JSON.parse(row.frontmatter_json);
   const merged = mergeStructuralOntoLocale(localeFm, enDoc.frontmatter, type.schema);
   const seo = seoFieldsFromEn(enDoc);
@@ -1011,6 +1486,14 @@ function buildDocumentFromTranslation(row, enDoc, type, config) {
     config.defaultLocale,
     config.localeRouting
   );
+  const preparedBody = prepareTranslatedMdxBody(row.body).body;
+  const content = inlineResolver ? fillTranslatedInlineBody(
+    preparedBody,
+    enDoc.content,
+    enDoc.frontmatter,
+    row.locale,
+    inlineResolver
+  ) : preparedBody;
   return {
     slug: row.slug,
     enSlug: row.en_slug,
@@ -1020,14 +1503,19 @@ function buildDocumentFromTranslation(row, enDoc, type, config) {
     noindex: seo.noindex,
     canonicalPathOverride: seo.canonicalPathOverride,
     frontmatter,
-    content: prepareTranslatedMdxBody(row.body).body
+    content
   };
 }
 var DEV_REVALIDATE_MS = 1500;
-function createContentLoader(config, type) {
+var contentVersion = 0;
+function bumpContentVersion() {
+  contentVersion++;
+}
+function createContentLoader(config, type, options = {}) {
   let cached = null;
   let signature = "";
   let lastCheck = 0;
+  let builtVersion = contentVersion;
   const contentDir = path3__default.default.join(
     /* turbopackIgnore: true */
     config.rootDir,
@@ -1035,18 +1523,34 @@ function createContentLoader(config, type) {
   );
   const storePath = resolveStorePath(config);
   const isProd = process.env.NODE_ENV === "production";
+  const assets = config.assets;
+  const assetFields = assets && options.resolveAssets ? listAssetFields(type.schema) : [];
+  const resolveAssets = (doc) => {
+    if (assetFields.length > 0 && assets) resolveDocumentAssets(doc, assetFields, assets);
+  };
+  const inlineResolver = options.inlineResolver;
+  const resolveEnInline = (doc) => {
+    if (inlineResolver) {
+      doc.content = substituteEnInlineBody(
+        doc.content,
+        doc.frontmatter,
+        config.defaultLocale,
+        inlineResolver
+      );
+    }
+  };
   function computeSignature() {
     const files = listEnFiles(contentDir);
     let newest = 0;
     for (const f of files) {
       try {
-        newest = Math.max(newest, fs2__default.default.statSync(f).mtimeMs);
+        newest = Math.max(newest, fs14__default.default.statSync(f).mtimeMs);
       } catch {
       }
     }
     let store = 0;
     try {
-      store = fs2__default.default.statSync(storePath).mtimeMs;
+      store = fs14__default.default.statSync(storePath).mtimeMs;
     } catch {
     }
     return `${files.length}:${newest}:${store}`;
@@ -1092,16 +1596,28 @@ function createContentLoader(config, type) {
       for (const row of rowsByLocale.get(locale) ?? []) {
         const enDoc = englishBySlug.get(row.en_slug);
         if (!enDoc) continue;
-        const doc = buildDocumentFromTranslation(row, enDoc, type, config);
+        const doc = buildDocumentFromTranslation(row, enDoc, type, config, inlineResolver);
+        resolveAssets(doc);
         bySlug.set(doc.slug, doc);
         byEnSlug.set(row.en_slug, doc);
       }
       out.set(locale, { bySlug, byEnSlug });
     }
+    for (const doc of englishBySlug.values()) {
+      resolveAssets(doc);
+      resolveEnInline(doc);
+    }
     return out;
   }
   return () => {
     if (cached) {
+      if (contentVersion !== builtVersion) {
+        cached = build();
+        builtVersion = contentVersion;
+        lastCheck = Date.now();
+        signature = isProd ? "" : computeSignature();
+        return cached;
+      }
       if (isProd) return cached;
       const now = Date.now();
       if (now - lastCheck < DEV_REVALIDATE_MS) return cached;
@@ -1114,6 +1630,7 @@ function createContentLoader(config, type) {
     }
     lastCheck = Date.now();
     cached = build();
+    builtVersion = contentVersion;
     signature = isProd ? "" : computeSignature();
     return cached;
   };
@@ -1126,7 +1643,7 @@ function readEnDocument(config, type, enSlug) {
   );
   for (const ext of [".mdx", ".md"]) {
     const filePath = path3__default.default.join(contentDir, `${enSlug}${ext}`);
-    if (!fs2__default.default.existsSync(filePath)) continue;
+    if (!fs14__default.default.existsSync(filePath)) continue;
     const { document: document2 } = parseEnMdx(filePath, config, type);
     return document2;
   }
@@ -1135,7 +1652,9 @@ function readEnDocument(config, type, enSlug) {
 function getTranslatablePayload(doc, type) {
   return {
     frontmatter: pickTranslatable(doc.frontmatter, type.schema),
-    body: doc.content
+    // Bodyless types never contribute a body to any translation payload, hash,
+    // or snapshot — regardless of what a document's `content` happens to hold.
+    body: type.body === false ? "" : doc.content
   };
 }
 
@@ -1223,8 +1742,11 @@ function comparatorFor(orderBy) {
       return (a, b) => a.slug.localeCompare(b.slug);
   }
 }
-function buildRuntime(config, type, getRuntime) {
-  const load = createContentLoader(config, type);
+function buildRuntime(config, type, getRuntime, options = {}) {
+  const load = createContentLoader(config, type, {
+    resolveAssets: options.resolveAssets,
+    inlineResolver: options.inlineResolver
+  });
   const relationFields = new Map(
     listRelationFields(type.schema).filter((f) => f.path.length === 1).map((f) => [f.path[0], f])
   );
@@ -1241,12 +1763,12 @@ function buildRuntime(config, type, getRuntime) {
     id: type.id,
     config: type,
     load,
-    list(locale = config.defaultLocale, options = {}) {
+    list(locale = config.defaultLocale, options2 = {}) {
       const idx = load().get(locale);
       if (!idx) return [];
       const docs = Array.from(idx.bySlug.values());
-      docs.sort(comparatorFor(options.orderBy ?? type.orderBy ?? "slug"));
-      return options.limit !== void 0 ? docs.slice(0, options.limit) : docs;
+      docs.sort(comparatorFor(options2.orderBy ?? type.orderBy ?? "slug"));
+      return options2.limit !== void 0 ? docs.slice(0, options2.limit) : docs;
     },
     get(slug, locale = config.defaultLocale) {
       return load().get(locale)?.bySlug.get(slug) ?? null;
@@ -1259,7 +1781,7 @@ function buildRuntime(config, type, getRuntime) {
         load(),
         type,
         config.localeRouting,
-        config.localeFallbacks[locale] ?? []
+        config.localeFallbacks?.[locale] ?? []
       );
       if (result.document && type.path) {
         return {
@@ -1273,15 +1795,15 @@ function buildRuntime(config, type, getRuntime) {
       }
       return result;
     },
-    staticParams(options = {}) {
+    staticParams(options2 = {}) {
       assertRoutable("staticParams");
       const all = load();
       const enIdx = all.get(config.defaultLocale);
       if (!enIdx) return [];
       const params = [];
-      for (const locale of options.locales ?? config.locales) {
+      for (const locale of options2.locales ?? config.locales) {
         const localeIdx = all.get(locale);
-        const fallbacks = config.localeFallbacks[locale] ?? [];
+        const fallbacks = config.localeFallbacks?.[locale] ?? [];
         for (const doc of enIdx.bySlug.values()) {
           let slug;
           if (locale === config.defaultLocale) {
@@ -1360,7 +1882,7 @@ function buildRuntime(config, type, getRuntime) {
   };
   return runtime;
 }
-function createProject(config) {
+function createProject(config, options = {}) {
   const runtimes = /* @__PURE__ */ new Map();
   const getRuntime = (id) => {
     const runtime = runtimes.get(id);
@@ -1369,8 +1891,18 @@ function createProject(config) {
     }
     return runtime;
   };
+  const inlineResolver = options.resolveInlineTokens ? createInlineResolver(config, {
+    linkStyle: options.inlineLinkStyle,
+    exportExtension: options.exportLinkExtension
+  }) : void 0;
   for (const type of config.types) {
-    runtimes.set(type.id, buildRuntime(config, type, getRuntime));
+    runtimes.set(
+      type.id,
+      buildRuntime(config, type, getRuntime, {
+        resolveAssets: options.resolveAssets,
+        inlineResolver
+      })
+    );
   }
   return {
     config,
@@ -1387,12 +1919,12 @@ function createProject(config) {
 }
 function enFileExists(config, type, enSlug) {
   const dir = path3__default.default.join(config.rootDir, type.contentDir);
-  return fs2__default.default.existsSync(path3__default.default.join(dir, `${enSlug}.mdx`)) || fs2__default.default.existsSync(path3__default.default.join(dir, `${enSlug}.md`));
+  return fs14__default.default.existsSync(path3__default.default.join(dir, `${enSlug}.mdx`)) || fs14__default.default.existsSync(path3__default.default.join(dir, `${enSlug}.md`));
 }
 function listEnSlugs(rootDir, contentDir) {
   const dir = path3__default.default.join(rootDir, contentDir);
-  if (!fs2__default.default.existsSync(dir)) return [];
-  return fs2__default.default.readdirSync(dir).filter(isPublishableContentFile).map((f) => f.replace(/\.(md|mdx)$/, ""));
+  if (!fs14__default.default.existsSync(dir)) return [];
+  return fs14__default.default.readdirSync(dir).filter(isPublishableContentFile).map((f) => f.replace(/\.(md|mdx)$/, ""));
 }
 
 // src/i18n/translation-index.ts
@@ -1488,10 +2020,10 @@ function redirectsFilePath(config, type) {
 }
 function loadTypeRedirectsFile(config, type) {
   const filePath = redirectsFilePath(config, type);
-  if (!fs2__default.default.existsSync(filePath)) return null;
+  if (!fs14__default.default.existsSync(filePath)) return null;
   let raw;
   try {
-    raw = JSON.parse(fs2__default.default.readFileSync(filePath, "utf8"));
+    raw = JSON.parse(fs14__default.default.readFileSync(filePath, "utf8"));
   } catch (error) {
     throw new Error(
       `${type.id}: failed to parse ${TYPE_REDIRECTS_FILENAME}: ${error instanceof Error ? error.message : String(error)}`
@@ -1799,8 +2331,8 @@ function getRedirectSourceSlugs(project) {
 // src/sitemap/join-base-url.ts
 function joinBaseUrl(baseUrl, pathname) {
   const origin = baseUrl.replace(/\/$/, "");
-  const path13 = pathname.startsWith("/") ? pathname : `/${pathname}`;
-  return `${origin}${path13}`;
+  const path15 = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return `${origin}${path15}`;
 }
 
 // src/sitemap/generate-sitemap.ts
@@ -1885,7 +2417,11 @@ async function generateSitemap(project, options) {
 // src/create-scribe.ts
 function createScribe(input) {
   const config = resolveConfig(input);
-  const project = createProject(config);
+  const project = createProject(config, {
+    resolveAssets: true,
+    resolveInlineTokens: true,
+    inlineLinkStyle: "app"
+  });
   const scribe = {
     config,
     project,
@@ -1894,6 +2430,17 @@ function createScribe(input) {
     listRoutableTypes: project.listRoutableTypes,
     sitemap(options) {
       return generateSitemap(project, options);
+    },
+    assets: {
+      url(ref, opts) {
+        if (opts && Object.keys(opts).length > 0) {
+          throw new Error(
+            `scribe.assets.url: options are reserved for a future pipeline; got ${Object.keys(opts).join(", ")}`
+          );
+        }
+        const assetsConfig = config.assets;
+        return assetsConfig ? joinPublicPath(assetsConfig.publicPath, ref) : ref;
+      }
     }
   };
   for (const type of config.types) {
@@ -1920,7 +2467,7 @@ function findConfigPath(cwd) {
     )
   ];
   for (const candidate of candidates) {
-    if (fs2__default.default.existsSync(candidate) && fs2__default.default.statSync(candidate).isFile()) {
+    if (fs14__default.default.existsSync(candidate) && fs14__default.default.statSync(candidate).isFile()) {
       return candidate;
     }
   }
@@ -1972,7 +2519,7 @@ function validateTypeRedirects(project) {
   const globalFrom = /* @__PURE__ */ new Map();
   for (const type of project.config.types) {
     const filePath = path3__default.default.join(project.config.rootDir, type.contentDir, TYPE_REDIRECTS_FILENAME);
-    if (!fs2__default.default.existsSync(filePath)) continue;
+    if (!fs14__default.default.existsSync(filePath)) continue;
     let loaded;
     try {
       loaded = loadTypeRedirectsFile(project.config, type);
@@ -2125,8 +2672,8 @@ function buildEnSlugIndex(config) {
 }
 function listEnSlugsForType(rootDir, contentDir) {
   const dir = path3__default.default.join(rootDir, contentDir);
-  if (!fs2__default.default.existsSync(dir)) return [];
-  return fs2__default.default.readdirSync(dir).filter(isPublishableContentFile).map((f) => f.replace(/\.(md|mdx)$/, ""));
+  if (!fs14__default.default.existsSync(dir)) return [];
+  return fs14__default.default.readdirSync(dir).filter(isPublishableContentFile).map((f) => f.replace(/\.(md|mdx)$/, ""));
 }
 function validateRelations(project) {
   const { config } = project;
@@ -2234,13 +2781,14 @@ function collectImagePaths(frontmatter, body) {
 function assetFilePath(assetsPath, webPath) {
   return path3__default.default.join(assetsPath, webPath.replace(/^\//, ""));
 }
-function validateDocumentAssets(config, input) {
+function validateDocumentAssets(config, input, skipPaths) {
   const assetsPath = config.assetsPath;
   if (!assetsPath) return [];
   const issues = [];
   for (const webPath of collectImagePaths(input.frontmatter, input.body)) {
+    if (skipPaths?.has(webPath)) continue;
     const filePath = assetFilePath(assetsPath, webPath);
-    if (fs2__default.default.existsSync(filePath)) continue;
+    if (fs14__default.default.existsSync(filePath)) continue;
     issues.push({
       level: "warning",
       contentType: input.contentType,
@@ -2252,6 +2800,115 @@ function validateDocumentAssets(config, input) {
   }
   return issues;
 }
+function collectAssetValues(container, path15, out, fieldPathSoFar = []) {
+  const [head, ...rest] = path15;
+  if (head === void 0) return;
+  if (typeof container !== "object" || container === null || Array.isArray(container)) return;
+  const record = container;
+  if (rest.length === 0) {
+    const value = record[head];
+    out.push({
+      fieldPath: [...fieldPathSoFar, head].join("."),
+      value: typeof value === "string" ? value : void 0
+    });
+    return;
+  }
+  if (rest[0] === "*") {
+    const arr = record[head];
+    if (!Array.isArray(arr)) {
+      out.push({ fieldPath: [...fieldPathSoFar, head, "*", ...rest.slice(1)].join("."), value: void 0 });
+      return;
+    }
+    arr.forEach((item) => {
+      collectAssetValues(item, rest.slice(1), out, [...fieldPathSoFar, head, "*"]);
+    });
+    return;
+  }
+  collectAssetValues(record[head], rest, out, [...fieldPathSoFar, head]);
+}
+function normalizeDir(dir) {
+  return `/${dir.replace(/^\/+|\/+$/g, "")}`;
+}
+function validateDeclaredAssetFields(config, input) {
+  const assetsPath = config.assetsPath;
+  if (!assetsPath) return [];
+  const issues = [];
+  const attrib = (fieldPath, level, message) => issues.push({
+    level,
+    contentType: input.contentType,
+    enSlug: input.enSlug,
+    locale: input.locale,
+    field: fieldPath,
+    message
+  });
+  for (const f of listAssetFields(input.schema)) {
+    const locations = [];
+    collectAssetValues(input.frontmatter, f.path, locations);
+    for (const { fieldPath, value } of locations) {
+      let effective = value;
+      if (effective === void 0 && f.assetTemplate) {
+        effective = f.assetTemplate.split("{slug}").join(input.enSlug);
+      }
+      if (effective === void 0) {
+        if (!f.assetOptional) {
+          attrib(fieldPath, "error", `${input.contentType}/${input.enSlug}: ${fieldPath} is required but missing`);
+        }
+        continue;
+      }
+      if (f.assetDir) {
+        const dir = normalizeDir(f.assetDir);
+        if (!(effective === dir || effective.startsWith(`${dir}/`))) {
+          attrib(
+            fieldPath,
+            "error",
+            `${input.contentType}/${input.enSlug}: ${fieldPath} value ${effective} is outside declared dir ${dir}`
+          );
+        }
+      }
+      const filePath = assetFilePath(assetsPath, effective);
+      if (!fs14__default.default.existsSync(filePath)) {
+        attrib(fieldPath, "error", `${input.contentType}/${input.enSlug}: ${fieldPath} \u2192 ${effective} not found`);
+        continue;
+      }
+      if (f.assetFormats && f.assetFormats.length > 0) {
+        const ext = path3__default.default.extname(effective).slice(1).toLowerCase();
+        if (!f.assetFormats.includes(ext)) {
+          attrib(
+            fieldPath,
+            "warning",
+            `${input.contentType}/${input.enSlug}: ${fieldPath} \u2192 ${effective} extension .${ext} not in formats [${f.assetFormats.join(", ")}]`
+          );
+        }
+      }
+      if (f.assetMaxKB !== void 0) {
+        try {
+          const sizeKB = fs14__default.default.statSync(filePath).size / 1024;
+          if (sizeKB > f.assetMaxKB) {
+            attrib(
+              fieldPath,
+              "warning",
+              `${input.contentType}/${input.enSlug}: ${fieldPath} \u2192 ${effective} is ${Math.round(sizeKB)}KB, over the ${f.assetMaxKB}KB budget`
+            );
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return issues;
+}
+function collectDeclaredAssetPaths(frontmatter, enSlug, schema, fields) {
+  const out = /* @__PURE__ */ new Set();
+  for (const f of listAssetFields(schema)) {
+    const locations = [];
+    collectAssetValues(frontmatter, f.path, locations);
+    for (const { value } of locations) {
+      if (value !== void 0) out.add(value);
+      else if (f.assetTemplate) out.add(f.assetTemplate.split("{slug}").join(enSlug));
+    }
+  }
+  return out;
+}
 
 // src/core/localized-slug.ts
 function findLocaleSuffixInSlug(slug, localeCodes) {
@@ -2294,15 +2951,151 @@ function validateTranslationSlugSuffixes(config, db) {
   }
   return issues;
 }
+function listEnSlugs3(rootDir, contentDir) {
+  const dir = path3__default.default.join(rootDir, contentDir);
+  if (!fs14__default.default.existsSync(dir)) return [];
+  return fs14__default.default.readdirSync(dir).filter(isPublishableContentFile).map((f) => f.replace(/\.(md|mdx)$/, ""));
+}
+function isStringRecord2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return Object.values(value).every((v) => typeof v === "string");
+}
+function assetFileExists(config, webPath) {
+  const assetsPath = config.assetsPath;
+  if (!assetsPath) return true;
+  return fs14__default.default.existsSync(path3__default.default.join(assetsPath, webPath.replace(/^\//, "")));
+}
+function validateInlineTokens(config) {
+  const issues = [];
+  const slugIndex = buildEnSlugIndex(config);
+  const typeIds = new Set(config.types.map((t) => t.id));
+  const typeById = new Map(config.types.map((t) => [t.id, t]));
+  for (const type of config.types) {
+    for (const enSlug of listEnSlugs3(config.rootDir, type.contentDir)) {
+      const doc = readEnDocument(config, type, enSlug);
+      if (!doc) continue;
+      const { tokens, malformed } = extractInlineTokens(doc.content);
+      for (const bad of malformed) {
+        issues.push({
+          level: "error",
+          contentType: type.id,
+          enSlug,
+          field: "body",
+          message: `Malformed inline token (${bad.reason}): ${bad.raw}`
+        });
+      }
+      let varsReported = false;
+      const vars = doc.frontmatter.vars;
+      for (const token of tokens) {
+        switch (token.kind) {
+          case "static":
+            break;
+          case "relation": {
+            if (!typeIds.has(token.targetTypeId)) {
+              issues.push({
+                level: "error",
+                contentType: type.id,
+                enSlug,
+                field: "body",
+                message: `Inline relation token targets unknown type "${token.targetTypeId}"`
+              });
+              break;
+            }
+            const targetSlugs = slugIndex.get(token.targetTypeId) ?? /* @__PURE__ */ new Set();
+            if (!targetSlugs.has(token.enSlug)) {
+              issues.push({
+                level: "error",
+                contentType: type.id,
+                enSlug,
+                field: "body",
+                message: `Inline relation token references "${token.enSlug}", but no ${token.targetTypeId} doc has that slug`
+              });
+              break;
+            }
+            if (token.mode === "href") {
+              const targetType = typeById.get(token.targetTypeId);
+              if (!isRoutableType(targetType)) {
+                issues.push({
+                  level: "error",
+                  contentType: type.id,
+                  enSlug,
+                  field: "body",
+                  message: `Inline relation token resolves a URL for "${token.targetTypeId}", which has no path template (not routable)`
+                });
+              }
+            }
+            break;
+          }
+          case "asset": {
+            if (!assetFileExists(config, token.webPath)) {
+              issues.push({
+                level: "error",
+                contentType: type.id,
+                enSlug,
+                field: "body",
+                message: `Inline asset token references ${token.webPath}, which is missing on disk`
+              });
+            }
+            break;
+          }
+          case "var": {
+            if (vars !== void 0 && !isStringRecord2(vars)) {
+              if (!varsReported) {
+                varsReported = true;
+                issues.push({
+                  level: "error",
+                  contentType: type.id,
+                  enSlug,
+                  field: "vars",
+                  message: `Frontmatter "vars" must be a string-to-string map`
+                });
+              }
+              break;
+            }
+            if (!isStringRecord2(vars) || !(token.key in vars)) {
+              issues.push({
+                level: "error",
+                contentType: type.id,
+                enSlug,
+                field: "body",
+                message: `Inline var token references "${token.key}", absent from this document's vars map`
+              });
+            }
+            break;
+          }
+        }
+      }
+    }
+  }
+  return issues;
+}
 
 // src/validate/validate-project.ts
-function listEnSlugs3(rootDir, contentDir) {
+function listEnSlugs4(rootDir, contentDir) {
   const dir = path3__default.default.join(rootDir, contentDir);
-  if (!fs2__default.default.existsSync(dir)) return [];
-  return fs2__default.default.readdirSync(dir).filter(isPublishableContentFile).map((f) => f.replace(/\.(md|mdx)$/, ""));
+  if (!fs14__default.default.existsSync(dir)) return [];
+  return fs14__default.default.readdirSync(dir).filter(isPublishableContentFile).map((f) => f.replace(/\.(md|mdx)$/, ""));
+}
+function validateBodylessEntry(issues, config, type, enSlug) {
+  const contentDir = path3__default.default.join(config.rootDir, type.contentDir);
+  for (const ext of [".mdx", ".md"]) {
+    const filePath = path3__default.default.join(contentDir, `${enSlug}${ext}`);
+    if (!fs14__default.default.existsSync(filePath)) continue;
+    const body = matter4__default.default(fs14__default.default.readFileSync(filePath, "utf8")).content;
+    if (body.trim().length > 0) {
+      issues.push({
+        level: "error",
+        contentType: type.id,
+        enSlug,
+        field: "body",
+        message: `type "${type.id}" is frontmatter-only (body: false) but the entry has body content`
+      });
+    }
+    return;
+  }
 }
 function validateDocumentMdxBody(issues, input) {
-  const preparedBody = prepareTranslatedMdxBody(input.body).body;
+  const preparedBody = prepareTranslatedMdxBody(maskInlineTokensForMdx(input.body)).body;
   const mdxValidation = validateMdxBody(preparedBody);
   if (!mdxValidation.ok) {
     issues.push({
@@ -2319,7 +3112,7 @@ function validateProject(config) {
   const issues = [];
   const project = createProject(config);
   const storePath = project.storePath;
-  if (!fs2__default.default.existsSync(storePath)) {
+  if (!fs14__default.default.existsSync(storePath)) {
     issues.push({
       level: "error",
       message: `Missing store.sqlite at ${storePath}`
@@ -2328,7 +3121,7 @@ function validateProject(config) {
   }
   const db = openStore(config, "readonly");
   for (const type of config.types) {
-    const enSlugs = listEnSlugs3(config.rootDir, type.contentDir);
+    const enSlugs = listEnSlugs4(config.rootDir, type.contentDir);
     const englishSlugs = new Set(enSlugs);
     if (!type.translate && isRoutableType(type)) {
       issues.push({
@@ -2365,20 +3158,41 @@ function validateProject(config) {
           message: issue.message
         });
       }
-      for (const issue of validateDocumentAssets(config, {
+      for (const issue of validateDeclaredAssetFields(config, {
         contentType: type.id,
         enSlug,
         frontmatter: enDoc.frontmatter,
-        body: enDoc.content
+        schema: type.schema
       })) {
         issues.push(issue);
       }
-      validateDocumentMdxBody(issues, {
-        contentType: type.id,
+      const declaredAssetPaths = collectDeclaredAssetPaths(
+        enDoc.frontmatter,
         enSlug,
-        locale: config.defaultLocale,
-        body: enDoc.content
-      });
+        type.schema
+      );
+      for (const issue of validateDocumentAssets(
+        config,
+        {
+          contentType: type.id,
+          enSlug,
+          frontmatter: enDoc.frontmatter,
+          body: enDoc.content
+        },
+        declaredAssetPaths
+      )) {
+        issues.push(issue);
+      }
+      if (type.body === false) {
+        validateBodylessEntry(issues, config, type, enSlug);
+      } else {
+        validateDocumentMdxBody(issues, {
+          contentType: type.id,
+          enSlug,
+          locale: config.defaultLocale,
+          body: enDoc.content
+        });
+      }
       for (const locale of config.locales) {
         if (locale === config.defaultLocale) continue;
         const row = getTranslation(db, type.id, enSlug, locale);
@@ -2395,21 +3209,27 @@ function validateProject(config) {
           });
         }
         const preparedBody = prepareTranslatedMdxBody(row.body).body;
-        for (const issue of validateDocumentAssets(config, {
-          contentType: type.id,
-          enSlug,
-          locale,
-          frontmatter: localeFm,
-          body: preparedBody
-        })) {
+        for (const issue of validateDocumentAssets(
+          config,
+          {
+            contentType: type.id,
+            enSlug,
+            locale,
+            frontmatter: localeFm,
+            body: preparedBody
+          },
+          declaredAssetPaths
+        )) {
           issues.push(issue);
         }
-        validateDocumentMdxBody(issues, {
-          contentType: type.id,
-          enSlug,
-          locale,
-          body: row.body
-        });
+        if (type.body !== false) {
+          validateDocumentMdxBody(issues, {
+            contentType: type.id,
+            enSlug,
+            locale,
+            body: row.body
+          });
+        }
       }
     }
     try {
@@ -2435,6 +3255,9 @@ function validateProject(config) {
       message: issue.message
     });
   }
+  for (const issue of validateInlineTokens(config)) {
+    issues.push(issue);
+  }
   const dbForSuffix = openStore(config, "readonly");
   try {
     for (const issue of validateTranslationSlugSuffixes(config, dbForSuffix)) {
@@ -2459,6 +3282,10 @@ function computePageEnHash(translatableFrontmatter, body) {
   const payload = JSON.stringify({ frontmatter: translatableFrontmatter, body });
   return sha256(payload);
 }
+function computeTranslationEnHash(translatableFrontmatter, body) {
+  const { placeholderBody } = extractInlineTokens(body);
+  return computePageEnHash(translatableFrontmatter, placeholderBody);
+}
 
 // src/translate/worklist.ts
 function parseContentTypeFilter(contentType) {
@@ -2466,10 +3293,10 @@ function parseContentTypeFilter(contentType) {
   const ids = contentType.split(",").map((id) => id.trim()).filter(Boolean);
   return ids.length > 0 ? new Set(ids) : void 0;
 }
-function listEnSlugs4(rootDir, contentDir) {
+function listEnSlugs5(rootDir, contentDir) {
   const dir = path3__default.default.join(rootDir, contentDir);
-  if (!fs2__default.default.existsSync(dir)) return [];
-  return fs2__default.default.readdirSync(dir).filter(isPublishableContentFile).map((f) => f.replace(/\.(md|mdx)$/, ""));
+  if (!fs14__default.default.existsSync(dir)) return [];
+  return fs14__default.default.readdirSync(dir).filter(isPublishableContentFile).map((f) => f.replace(/\.(md|mdx)$/, ""));
 }
 function buildWorklist(config, options = {}) {
   const db = openStore(config, "readonly");
@@ -2478,12 +3305,16 @@ function buildWorklist(config, options = {}) {
   const contentTypes = parseContentTypeFilter(options.contentType);
   for (const type of config.types) {
     if (contentTypes && !contentTypes.has(type.id)) continue;
-    const enSlugs = options.enSlug ? [options.enSlug] : listEnSlugs4(config.rootDir, type.contentDir);
+    if (!isTypeTranslatable(type)) {
+      options.onSkipType?.(type);
+      continue;
+    }
+    const enSlugs = options.enSlug ? [options.enSlug] : listEnSlugs5(config.rootDir, type.contentDir);
     for (const enSlug of enSlugs) {
       const enDoc = readEnDocument(config, type, enSlug);
       if (!enDoc) continue;
       const payload = getTranslatablePayload(enDoc, type);
-      const currentEnHash = computePageEnHash(payload.frontmatter, payload.body);
+      const currentEnHash = computeTranslationEnHash(payload.frontmatter, payload.body);
       for (const locale of locales) {
         if (locale === config.defaultLocale) continue;
         const existing = getTranslation(db, type.id, enSlug, locale);
@@ -2945,9 +3776,22 @@ function buildTranslatableSubschema(schema) {
   if (Object.keys(out).length === 0) return null;
   return zod.z.object(out);
 }
-function buildGeminiResponseSchema(schema, slugStrategy) {
+function buildTranslatableSubschemaForPayload(schema, translatableFrontmatter) {
+  const full = buildTranslatableSubschema(schema);
+  if (!full) return null;
+  const filtered = {};
+  for (const [key, childSchema] of Object.entries(full.shape)) {
+    if (!(key in translatableFrontmatter)) continue;
+    const value = translatableFrontmatter[key];
+    if (value === void 0 || value === null) continue;
+    filtered[key] = childSchema;
+  }
+  if (Object.keys(filtered).length === 0) return null;
+  return zod.z.object(filtered);
+}
+function buildGeminiResponseSchema(schema, slugStrategy, translatableFrontmatter) {
   try {
-    const translatable = buildTranslatableSubschema(schema);
+    const translatable = translatableFrontmatter !== void 0 ? buildTranslatableSubschemaForPayload(schema, translatableFrontmatter) : buildTranslatableSubschema(schema);
     const responseShape = {
       ...translatable ? { frontmatter: translatable } : {},
       body: zod.z.string()
@@ -2969,9 +3813,12 @@ function buildGeminiResponseSchema(schema, slugStrategy) {
 
 // src/translate/resolve-translate-config.ts
 var BUILTIN_TRANSLATE_RULES = [
+  "Placeholders written as %%1%%, %%2%%, %%3%% (double percent signs around a number) are immutable. Reproduce each placeholder that appears in the source EXACTLY as-is, exactly once, and never translate, edit, renumber, or add spaces inside it. You may move a placeholder to a different position within its sentence when the target grammar requires it.",
   "Do not translate brand or product names unless the brand has a well-known localized name in the target market (rare). Keep the original spelling and capitalization.",
   "Return the MDX body with real line breaks; do not use JSON escape sequences like \\n or \\t in the body string.",
-  'In JSX attributes (e.g. FaqItem question="..."), use single quotes when the value contains double-quote characters (e.g. Hebrew \u05D3\u05D5\u05D0"\u05DC), or escape them as \\".'
+  'In JSX attributes (e.g. FaqItem question="..."), use single quotes when the value contains double-quote characters (e.g. Hebrew \u05D3\u05D5\u05D0"\u05DC), or escape them as \\".',
+  "Match the EN source format: when the EN body uses Markdown/MDX (headings, paragraphs, GFM tables, links), keep that structure in the translation. Do not convert markdown elements into raw HTML (<p>, <h2>, <table>, etc.).",
+  "Otherwise match the format and components used in the EN source."
 ];
 function slugStrategyRules(slugStrategy) {
   if (slugStrategy === "localized") {
@@ -3015,12 +3862,13 @@ function sanitizeTranslatedFrontmatter(rawFrontmatter, schema) {
   return pickTranslatable(rawFrontmatter, schema);
 }
 function validateTranslatedFrontmatter(enDoc, localeFrontmatter, typeSchema) {
-  const frontmatter = sanitizeTranslatedFrontmatter(localeFrontmatter, typeSchema);
-  const merged = mergeStructuralOntoLocale(
-    frontmatter,
-    enDoc.frontmatter,
+  const enFrontmatter = enDoc.frontmatter;
+  const frontmatter = pruneOrphanNestedTranslations(
+    sanitizeTranslatedFrontmatter(localeFrontmatter, typeSchema),
+    enFrontmatter,
     typeSchema
   );
+  const merged = mergeStructuralOntoLocale(frontmatter, enFrontmatter, typeSchema);
   const parsed = typeSchema.safeParse(merged);
   if (!parsed.success) {
     return { ok: false, error: formatZodIssues(parsed.error) };
@@ -3069,6 +3917,22 @@ function formatTranslateError(error) {
   }
   return message.length > 160 ? `${message.slice(0, 157)}\u2026` : message;
 }
+function verifyInlineMarkers(enRawBody, translatedBody) {
+  const { tokens } = extractInlineTokens(enRawBody);
+  if (tokens.length === 0) return;
+  const missing = [];
+  const duplicated = [];
+  for (let i = 1; i <= tokens.length; i++) {
+    const count = countMarkerOccurrences(translatedBody, i);
+    if (count === 0) missing.push(placeholderMarker(i));
+    else if (count > 1) duplicated.push(placeholderMarker(i));
+  }
+  if (missing.length === 0 && duplicated.length === 0) return;
+  const parts = [];
+  if (missing.length > 0) parts.push(`missing ${missing.join(", ")}`);
+  if (duplicated.length > 0) parts.push(`duplicated ${duplicated.join(", ")}`);
+  throw new Error(`Inline token markers mismatch: ${parts.join("; ")}`);
+}
 function resolveContextLabel(enDoc, enSlug) {
   const fm = enDoc.frontmatter;
   for (const key of ["title", "name", "h1"]) {
@@ -3090,7 +3954,8 @@ function prepareTranslation(config, item, options, startedAt) {
   const enDoc = readEnDocument(config, type, item.enSlug);
   if (!enDoc) throw new Error(`EN document not found: ${item.enSlug}`);
   const payload = getTranslatablePayload(enDoc, type);
-  const currentEnHash = computePageEnHash(payload.frontmatter, payload.body);
+  const { placeholderBody } = extractInlineTokens(payload.body);
+  const currentEnHash = computeTranslationEnHash(payload.frontmatter, payload.body);
   const db = openStore(config, "readonly");
   const existing = getTranslation(db, type.id, item.enSlug, item.locale);
   db.close();
@@ -3112,11 +3977,15 @@ function prepareTranslation(config, item, options, startedAt) {
     targetLocale: item.locale,
     contextLabel: resolveContextLabel(enDoc, item.enSlug),
     translatableFrontmatter: payload.frontmatter,
-    enBody: payload.body,
+    enBody: placeholderBody,
     slugStrategy: type.slugStrategy,
     previousError: item.previousError
   });
-  const responseSchema = buildGeminiResponseSchema(type.schema, type.slugStrategy);
+  const responseSchema = buildGeminiResponseSchema(
+    type.schema,
+    type.slugStrategy,
+    payload.frontmatter
+  );
   return {
     status: "ready",
     prepared: {
@@ -3144,9 +4013,8 @@ function finalizeTranslation(config, prepared, output, options) {
     if (!validated.ok) {
       throw new Error(`Translation validation failed: ${validated.error}`);
     }
-    const { body: translatedBody, adjusted: mdxAdjusted } = assertValidTranslatedMdxBody(
-      output.parsed.body
-    );
+    const { body: translatedBody, adjusted: mdxAdjusted } = type.body === false ? { body: "", adjusted: false } : assertValidTranslatedMdxBody(output.parsed.body);
+    verifyInlineMarkers(payload.body, translatedBody);
     const writeDb = openStore(config, "readwrite");
     const snapshotId = options.snapshotId ?? recordEnSnapshot(
       config,
@@ -3860,7 +4728,7 @@ async function resumeTranslationJobs(config, options = {}) {
   return results;
 }
 function serializeMdx(frontmatter, content) {
-  return matter__default.default.stringify(content, frontmatter);
+  return matter4__default.default.stringify(content, frontmatter);
 }
 
 // src/export/build-static-raw-exports.ts
@@ -3927,8 +4795,8 @@ function buildStaticRawExports(project, options = {}) {
   return out;
 }
 function rmDirIfExists(dir) {
-  if (fs2__default.default.existsSync(dir)) {
-    fs2__default.default.rmSync(dir, { recursive: true, force: true });
+  if (fs14__default.default.existsSync(dir)) {
+    fs14__default.default.rmSync(dir, { recursive: true, force: true });
   }
 }
 function writeStaticRawExports(project, options = {}) {
@@ -3944,8 +4812,8 @@ function writeStaticRawExports(project, options = {}) {
   const counts = /* @__PURE__ */ new Map();
   for (const item of exports) {
     const filePath = path3__default.default.join(outDir, item.relativePath);
-    fs2__default.default.mkdirSync(path3__default.default.dirname(filePath), { recursive: true });
-    fs2__default.default.writeFileSync(filePath, item.source, "utf8");
+    fs14__default.default.mkdirSync(path3__default.default.dirname(filePath), { recursive: true });
+    fs14__default.default.writeFileSync(filePath, item.source, "utf8");
     const key = `${item.typeId}/${item.locale}`;
     counts.set(key, (counts.get(key) ?? 0) + 1);
   }
@@ -3955,7 +4823,411 @@ function writeStaticRawExports(project, options = {}) {
   return { exports, written: exports.length };
 }
 
+// src/delete/plan.ts
+function isPlanBlocked(plan) {
+  return plan.blocked.length > 0;
+}
+function deletedDocs(plan) {
+  return [
+    ...plan.roots.map((r) => ({ typeId: r.typeId, enSlug: r.enSlug })),
+    ...plan.cascades.map((c) => ({ typeId: c.typeId, enSlug: c.enSlug }))
+  ];
+}
+function docKey(typeId, enSlug) {
+  return `${typeId}\0${enSlug}`;
+}
+function relationSlugsAt(frontmatter, path15) {
+  const out = [];
+  const walk = (container, remaining) => {
+    const [head, ...rest] = remaining;
+    if (head === void 0) return;
+    if (typeof container !== "object" || container === null || Array.isArray(container)) return;
+    const record = container;
+    if (rest.length === 0) {
+      const value = record[head];
+      if (Array.isArray(value)) {
+        for (const slug of value) if (typeof slug === "string" && slug) out.push(slug);
+      } else if (typeof value === "string" && value) {
+        out.push(value);
+      }
+      return;
+    }
+    if (rest[0] === "*") {
+      const arr = record[head];
+      if (Array.isArray(arr)) for (const item of arr) walk(item, rest.slice(1));
+      return;
+    }
+    walk(record[head], rest);
+  };
+  walk(frontmatter, path15);
+  return out;
+}
+function assetValuesAt(frontmatter, field2, enSlug) {
+  const out = [];
+  const walk = (container, remaining) => {
+    const [head, ...rest] = remaining;
+    if (head === void 0) return;
+    if (typeof container !== "object" || container === null || Array.isArray(container)) return;
+    const record = container;
+    if (rest.length === 0) {
+      const value = record[head];
+      if (typeof value === "string" && value) out.push(value);
+      else if (value === void 0 && field2.assetTemplate) {
+        out.push(field2.assetTemplate.split("{slug}").join(enSlug));
+      }
+      return;
+    }
+    if (rest[0] === "*") {
+      const arr = record[head];
+      if (Array.isArray(arr)) for (const item of arr) walk(item, rest.slice(1));
+      return;
+    }
+    walk(record[head], rest);
+  };
+  walk(frontmatter, field2.path);
+  return out;
+}
+function buildDeletionPlan(project, typeId, enSlug) {
+  const rootType = (() => {
+    try {
+      return project.getType(typeId);
+    } catch {
+      return null;
+    }
+  })();
+  if (!rootType) {
+    throw new Error(`Unknown content type "${typeId}"`);
+  }
+  const rootDoc = rootType.get(enSlug);
+  if (!rootDoc) {
+    throw new Error(`No ${typeId} entry "${enSlug}"`);
+  }
+  const docByKey = /* @__PURE__ */ new Map();
+  const relationFieldsByType = /* @__PURE__ */ new Map();
+  const assetFieldsByType = /* @__PURE__ */ new Map();
+  const referrers = /* @__PURE__ */ new Map();
+  const assetRefs = /* @__PURE__ */ new Map();
+  const bodyRelationRefs = [];
+  for (const type of project.listTypes()) {
+    const relFields = listRelationFields(type.config.schema);
+    const assetFields = listAssetFields(type.config.schema);
+    relationFieldsByType.set(type.id, relFields);
+    assetFieldsByType.set(type.id, assetFields);
+    for (const doc of type.list()) {
+      const frontmatter = doc.frontmatter;
+      docByKey.set(docKey(type.id, doc.enSlug), {
+        typeId: type.id,
+        enSlug: doc.enSlug,
+        frontmatter
+      });
+      for (const field2 of relFields) {
+        const target = field2.relationTarget;
+        if (!target) continue;
+        for (const slug of relationSlugsAt(frontmatter, field2.path)) {
+          const list = referrers.get(docKey(target, slug)) ?? [];
+          list.push({
+            typeId: type.id,
+            enSlug: doc.enSlug,
+            fieldPath: field2.path.join("."),
+            multiple: Boolean(field2.relationMultiple),
+            optional: Boolean(field2.relationOptional),
+            onTargetDelete: field2.relationOnTargetDelete ?? "restrict"
+          });
+          referrers.set(docKey(target, slug), list);
+        }
+      }
+      for (const field2 of assetFields) {
+        for (const webPath of assetValuesAt(frontmatter, field2, doc.enSlug)) {
+          const set = assetRefs.get(webPath) ?? /* @__PURE__ */ new Set();
+          set.add(docKey(type.id, doc.enSlug));
+          assetRefs.set(webPath, set);
+        }
+      }
+      for (const token of extractInlineTokens(doc.content).tokens) {
+        if (token.kind === "relation") {
+          bodyRelationRefs.push({
+            typeId: type.id,
+            enSlug: doc.enSlug,
+            targetTypeId: token.targetTypeId,
+            targetEnSlug: token.enSlug
+          });
+        }
+      }
+    }
+  }
+  const deleted = /* @__PURE__ */ new Map();
+  deleted.set(docKey(typeId, enSlug), { typeId, enSlug });
+  const queue = [{ typeId, enSlug }];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    for (const ref of referrers.get(docKey(current.typeId, current.enSlug)) ?? []) {
+      if (ref.onTargetDelete !== "cascade") continue;
+      const refKey = docKey(ref.typeId, ref.enSlug);
+      if (deleted.has(refKey)) continue;
+      deleted.set(refKey, {
+        typeId: ref.typeId,
+        enSlug: ref.enSlug,
+        via: `${ref.fieldPath}=${current.enSlug}`
+      });
+      queue.push({ typeId: ref.typeId, enSlug: ref.enSlug });
+    }
+  }
+  const detaches = [];
+  const blocked = [];
+  const seenDetach = /* @__PURE__ */ new Set();
+  const seenBlock = /* @__PURE__ */ new Set();
+  for (const del of deleted.values()) {
+    for (const ref of referrers.get(docKey(del.typeId, del.enSlug)) ?? []) {
+      if (deleted.has(docKey(ref.typeId, ref.enSlug))) continue;
+      if (ref.onTargetDelete === "restrict") {
+        const k = `${ref.typeId}\0${ref.enSlug}\0${ref.fieldPath}\0restrict`;
+        if (!seenBlock.has(k)) {
+          seenBlock.add(k);
+          blocked.push({
+            typeId: ref.typeId,
+            enSlug: ref.enSlug,
+            fieldPath: ref.fieldPath,
+            reason: "restrict"
+          });
+        }
+      } else if (ref.onTargetDelete === "detach") {
+        const requiredSingle = !ref.multiple && !ref.optional;
+        if (requiredSingle) {
+          const k = `${ref.typeId}\0${ref.enSlug}\0${ref.fieldPath}\0required-single`;
+          if (!seenBlock.has(k)) {
+            seenBlock.add(k);
+            blocked.push({
+              typeId: ref.typeId,
+              enSlug: ref.enSlug,
+              fieldPath: ref.fieldPath,
+              reason: "required-single"
+            });
+          }
+        } else {
+          const k = `${ref.typeId}\0${ref.enSlug}\0${ref.fieldPath}\0${del.enSlug}`;
+          if (!seenDetach.has(k)) {
+            seenDetach.add(k);
+            detaches.push({
+              typeId: ref.typeId,
+              enSlug: ref.enSlug,
+              fieldPath: ref.fieldPath,
+              removedSlug: del.enSlug
+            });
+          }
+        }
+      }
+    }
+  }
+  const assets = [];
+  const seenAsset = /* @__PURE__ */ new Set();
+  for (const del of deleted.values()) {
+    const record = docByKey.get(docKey(del.typeId, del.enSlug));
+    if (!record) continue;
+    for (const field2 of assetFieldsByType.get(del.typeId) ?? []) {
+      for (const webPath of assetValuesAt(record.frontmatter, field2, del.enSlug)) {
+        const dedupeKey = `${del.typeId}\0${del.enSlug}\0${webPath}`;
+        if (seenAsset.has(dedupeKey)) continue;
+        seenAsset.add(dedupeKey);
+        if (field2.assetOnDelete === "keep") {
+          assets.push({
+            path: webPath,
+            ownerTypeId: del.typeId,
+            ownerEnSlug: del.enSlug,
+            action: "keep",
+            reason: "config-keep"
+          });
+          continue;
+        }
+        const refs = assetRefs.get(webPath) ?? /* @__PURE__ */ new Set();
+        let sharedOutside = false;
+        for (const owner of refs) {
+          if (!deleted.has(owner)) {
+            sharedOutside = true;
+            break;
+          }
+        }
+        assets.push(
+          sharedOutside ? {
+            path: webPath,
+            ownerTypeId: del.typeId,
+            ownerEnSlug: del.enSlug,
+            action: "keep",
+            reason: "shared"
+          } : {
+            path: webPath,
+            ownerTypeId: del.typeId,
+            ownerEnSlug: del.enSlug,
+            action: "delete"
+          }
+        );
+      }
+    }
+  }
+  const store = [];
+  try {
+    const db = openStore(project.config, "readonly");
+    try {
+      for (const del of deleted.values()) {
+        store.push({
+          typeId: del.typeId,
+          enSlug: del.enSlug,
+          translations: countTranslationsForEnSlug(db, del.typeId, del.enSlug),
+          snapshots: countEnSnapshotsForEnSlug(db, del.typeId, del.enSlug)
+        });
+      }
+    } finally {
+      db.close();
+    }
+  } catch {
+    for (const del of deleted.values()) {
+      store.push({ typeId: del.typeId, enSlug: del.enSlug, translations: 0, snapshots: 0 });
+    }
+  }
+  const rootTitle = (() => {
+    const title = rootDoc.frontmatter.title;
+    return typeof title === "string" && title.trim() ? title : void 0;
+  })();
+  const cascades = [];
+  for (const del of deleted.values()) {
+    if (del.typeId === typeId && del.enSlug === enSlug) continue;
+    cascades.push({ typeId: del.typeId, enSlug: del.enSlug, via: del.via ?? "" });
+  }
+  const bodyRefWarnings = bodyRelationRefs.filter(
+    (ref) => deleted.has(docKey(ref.targetTypeId, ref.targetEnSlug)) && !deleted.has(docKey(ref.typeId, ref.enSlug))
+  );
+  return {
+    roots: [{ typeId, enSlug, title: rootTitle }],
+    cascades,
+    detaches,
+    blocked,
+    assets,
+    store,
+    bodyRefWarnings
+  };
+}
+function enFilePath(rootDir, contentDir, enSlug) {
+  for (const ext of [".mdx", ".md"]) {
+    const candidate = path3__default.default.join(rootDir, contentDir, `${enSlug}${ext}`);
+    if (fs14__default.default.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function rewriteFrontmatter(raw, data) {
+  const match = raw.match(/^()?---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*(\r?\n|$)/);
+  if (!match) {
+    throw new Error("Cannot rewrite frontmatter: no leading YAML block found");
+  }
+  const bom = match[1] ?? "";
+  const body = raw.slice(match[0].length);
+  const serialized = matter4__default.default.stringify("", data);
+  const blockMatch = serialized.match(/^---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*\r?\n/);
+  const block = blockMatch ? blockMatch[0] : serialized;
+  return `${bom}${block}${body}`;
+}
+function removeSlugAtPath(container, remaining, removedSlug, multiple) {
+  const [head, ...rest] = remaining;
+  if (head === void 0) return;
+  if (typeof container !== "object" || container === null || Array.isArray(container)) return;
+  const record = container;
+  if (rest.length === 0) {
+    if (multiple) {
+      const value = record[head];
+      if (Array.isArray(value)) {
+        record[head] = value.filter((slug) => slug !== removedSlug);
+      }
+    } else if (record[head] === removedSlug) {
+      delete record[head];
+    }
+    return;
+  }
+  if (rest[0] === "*") {
+    const arr = record[head];
+    if (Array.isArray(arr)) {
+      for (const item of arr) removeSlugAtPath(item, rest.slice(1), removedSlug, multiple);
+    }
+    return;
+  }
+  removeSlugAtPath(record[head], rest, removedSlug, multiple);
+}
+function executeDeletionPlan(project, plan) {
+  if (isPlanBlocked(plan)) {
+    throw new Error("Refusing to execute a blocked deletion plan");
+  }
+  const config = project.config;
+  const result = {
+    deletedFiles: [],
+    deletedAssets: [],
+    detachedFiles: [],
+    translationsDeleted: 0,
+    snapshotsDeleted: 0
+  };
+  const detachesByFile = /* @__PURE__ */ new Map();
+  for (const detach of plan.detaches) {
+    const key = `${detach.typeId} ${detach.enSlug}`;
+    const list = detachesByFile.get(key) ?? [];
+    list.push(detach);
+    detachesByFile.set(key, list);
+  }
+  for (const [, detaches] of detachesByFile) {
+    const { typeId, enSlug } = detaches[0];
+    const type = project.getType(typeId);
+    const file = enFilePath(config.rootDir, type.config.contentDir, enSlug);
+    if (!file) continue;
+    const fieldByPath = new Map(
+      listRelationFields(type.config.schema).map((f) => [f.path.join("."), f])
+    );
+    const raw = fs14__default.default.readFileSync(file, "utf8");
+    const data = structuredClone(matter4__default.default(raw).data);
+    for (const detach of detaches) {
+      const field2 = fieldByPath.get(detach.fieldPath);
+      if (!field2) continue;
+      removeSlugAtPath(
+        data,
+        detach.fieldPath.split("."),
+        detach.removedSlug,
+        Boolean(field2.relationMultiple)
+      );
+    }
+    fs14__default.default.writeFileSync(file, rewriteFrontmatter(raw, data), "utf8");
+    result.detachedFiles.push(file);
+  }
+  const assetsDir = config.assets?.assetsPath ?? config.assetsPath;
+  for (const asset of plan.assets) {
+    if (asset.action !== "delete") continue;
+    if (!assetsDir) continue;
+    const root = path3__default.default.resolve(assetsDir);
+    const relative = asset.path.replace(/^\/+/, "");
+    const abs = path3__default.default.resolve(root, relative);
+    const rootWithSep = root.endsWith(path3__default.default.sep) ? root : root + path3__default.default.sep;
+    if (abs !== root && !abs.startsWith(rootWithSep)) continue;
+    if (fs14__default.default.existsSync(abs)) {
+      fs14__default.default.rmSync(abs, { force: true });
+      result.deletedAssets.push(abs);
+    }
+  }
+  for (const doc of deletedDocs(plan)) {
+    const type = project.getType(doc.typeId);
+    const file = enFilePath(config.rootDir, type.config.contentDir, doc.enSlug);
+    if (file && fs14__default.default.existsSync(file)) {
+      fs14__default.default.rmSync(file, { force: true });
+      result.deletedFiles.push(file);
+    }
+  }
+  const db = openStore(config, "readwrite");
+  try {
+    for (const doc of deletedDocs(plan)) {
+      result.translationsDeleted += deleteTranslationsForEnSlug(db, doc.typeId, doc.enSlug);
+      result.snapshotsDeleted += deleteEnSnapshotsForEnSlug(db, doc.typeId, doc.enSlug);
+    }
+  } finally {
+    db.close();
+  }
+  bumpContentVersion();
+  return result;
+}
+
 exports.buildAllContentRedirects = buildAllContentRedirects;
+exports.buildDeletionPlan = buildDeletionPlan;
 exports.buildStaticRawExports = buildStaticRawExports;
 exports.buildWorklist = buildWorklist;
 exports.createProject = createProject;
@@ -3963,23 +5235,36 @@ exports.createScribe = createScribe;
 exports.createUrlBuilder = createUrlBuilder;
 exports.defineConfig = defineConfig;
 exports.defineContentType = defineContentType;
+exports.executeDeletionPlan = executeDeletionPlan;
 exports.exportDirSegment = exportDirSegment;
+exports.extractInlineTokens = extractInlineTokens;
 exports.field = field;
+exports.fillPlaceholders = fillPlaceholders;
 exports.findConfigPath = findConfigPath;
 exports.generateSitemap = generateSitemap;
+exports.getAssetMeta = getAssetMeta;
 exports.getFieldKind = getFieldKind;
+exports.getManagedRoots = getManagedRoots;
 exports.getRedirectSourceSlugs = getRedirectSourceSlugs;
 exports.getRelationTarget = getRelationTarget;
 exports.getStaticExportRoots = getStaticExportRoots;
+exports.introspectSchema = introspectSchema;
 exports.isResolvedConfig = isResolvedConfig;
 exports.isRoutableType = isRoutableType;
+exports.isTypeTranslatable = isTypeTranslatable;
+exports.listAssetFields = listAssetFields;
+exports.listRelationFields = listRelationFields;
+exports.listTranslatableFields = listTranslatableFields;
 exports.loadConfigSync = loadConfigSync;
+exports.placeholderMarker = placeholderMarker;
 exports.resolveConfig = resolveConfig;
 exports.resolveLocalesFromPreset = resolveLocalesFromPreset;
 exports.resumeTranslationJobs = resumeTranslationJobs;
 exports.serializeMdx = serializeMdx;
+exports.templateManagedRoot = templateManagedRoot;
 exports.translatePage = translatePage;
 exports.translateWorklist = translateWorklist;
+exports.unescapeInlineTokens = unescapeInlineTokens;
 exports.unwrapSchema = unwrapSchema;
 exports.validateProject = validateProject;
 exports.writeStaticRawExports = writeStaticRawExports;