scribe-cms 0.0.17 → 0.0.20

package/dist/runtime.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import { z } from 'zod';
-import fs2 from 'fs';
+import fs3 from 'fs';
 import matter from 'gray-matter';
 import Database from 'better-sqlite3';
 import remarkMdx from 'remark-mdx';
@@ -131,7 +131,15 @@ function resolveConfig(input, baseDir) {
   const projectRoot = path.resolve(process.cwd(), raw.rootDir);
   const contentRoot = path.resolve(projectRoot, raw.contentDir ?? "content");
   const storePath = path.resolve(projectRoot, raw.store ?? ".scribe/store.sqlite");
-  const assetsPath = raw.assetsDir ? path.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 = path.resolve(projectRoot, dir);
+    assets = { assetsPath, publicPath, managedDirs };
+  }
   const seenIds = /* @__PURE__ */ new Set();
   const types = raw.types.map((type) => {
     if (seenIds.has(type.id)) {
@@ -146,13 +154,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,
@@ -188,6 +200,7 @@ function deriveLocaleFallbacks(locales, defaultLocale) {
 }
 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";
@@ -215,6 +228,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 peelOptionalWrappers(schema) {
   let current = schema;
   for (let i = 0; i < 8; i++) {
@@ -248,7 +284,23 @@ function introspectSchema(schema, prefix = []) {
         kind: "relation",
         relationTarget: relation.typeId,
         relationMultiple: relation.multiple,
-        relationOptional: relation.optional
+        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
       }
     ];
   }
@@ -326,7 +378,7 @@ function pickTranslatable(data, schema) {
   return extractByPaths(data, translatablePaths);
 }
 function pickStructural(data, schema) {
-  const structuralPaths = introspectSchema(schema).filter((f) => f.kind === "structural" || f.kind === "relation").map((f) => f.path);
+  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) {
@@ -341,7 +393,7 @@ function deepMerge(base, overlay) {
       out[key] = deepMerge(out[key], value);
     } else if (Array.isArray(value) && Array.isArray(out[key])) {
       out[key] = mergeArrayOverlay(out[key], value);
-    } else {
+    } else if (value !== void 0) {
       out[key] = value;
     }
   }
@@ -359,6 +411,9 @@ function mergeArrayOverlay(base, overlay) {
 function listRelationFields(schema) {
   return introspectSchema(schema).filter((f) => f.kind === "relation");
 }
+function listAssetFields(schema) {
+  return introspectSchema(schema).filter((f) => f.kind === "asset");
+}
 var SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var slugPatternSchema = z.string().regex(SLUG_PATTERN, "slug must be lowercase-kebab-case");
 var isoDateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}(T[\d:.Z+-]*)?$/, "Use ISO date YYYY-MM-DD or full ISO 8601");
@@ -439,12 +494,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
@@ -474,6 +535,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) {
@@ -563,7 +625,7 @@ function resolveStorePath(config) {
 function openStore(config, mode = "readwrite") {
   const storePath = resolveStorePath(config);
   if (mode === "readwrite") {
-    fs2.mkdirSync(path.dirname(storePath), { recursive: true });
+    fs3.mkdirSync(path.dirname(storePath), { recursive: true });
   }
   const db = new Database(storePath, { readonly: mode === "readonly" });
   if (mode === "readwrite") {
@@ -602,6 +664,9 @@ function migrate(db) {
 function listTranslationsForType(db, contentType) {
   return db.prepare(`SELECT * FROM translations WHERE content_type = ? ORDER BY en_slug, locale`).all(contentType);
 }
+function bulkLoadTranslations(db) {
+  return db.prepare(`SELECT * FROM translations ORDER BY content_type, en_slug, locale`).all();
+}
 
 // src/translate/normalize-mdx-body.ts
 function needsMdxEscapeNormalization(body) {
@@ -718,6 +783,279 @@ function prepareTranslatedMdxBody(body) {
   };
 }
 
+// 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, path6, transform) {
+  const [head, ...rest] = path6;
+  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 < 2 || parts.length > 3) {
+        return {
+          ok: false,
+          reason: `relation must be relation:<typeId>:<enSlug> 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 !== void 0 && mode !== "slug") {
+        return { ok: false, reason: `relation mode must be "slug" (got "${mode}")` };
+      }
+      return {
+        ok: true,
+        token: {
+          kind: "relation",
+          targetTypeId,
+          enSlug,
+          mode: mode === "slug" ? "slug" : "url"
+        }
+      };
+    }
+    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);
+}
+
+// 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) {
+  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 = fs3.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 localizedSlug = (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 = localizedSlug(token.targetTypeId, token.enSlug, locale);
+          return urlBuilder.resolvePath(type.path, slug, locale);
+        }
+      }
+    }
+  };
+}
+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 };
@@ -743,14 +1081,14 @@ function isPostFile(name) {
   return isPublishableContentFile(name);
 }
 function listEnFiles(contentDir) {
-  if (!fs2.existsSync(contentDir)) return [];
-  return fs2.readdirSync(contentDir).filter(isPostFile).map((f) => path.join(contentDir, f));
+  if (!fs3.existsSync(contentDir)) return [];
+  return fs3.readdirSync(contentDir).filter(isPostFile).map((f) => path.join(contentDir, f));
 }
 function slugFromPath(filePath) {
   return path.basename(filePath).replace(/\.(md|mdx)$/, "");
 }
 function parseEnMdx(filePath, config, type) {
-  const raw = fs2.readFileSync(filePath, "utf8");
+  const raw = fs3.readFileSync(filePath, "utf8");
   const parsed = matter(raw);
   const slug = slugFromPath(filePath);
   const normalized = normalizeEnFrontmatter(parsed.data);
@@ -789,6 +1127,7 @@ function parseEnMdx(filePath, config, type) {
       updatedAt: builtin.updatedAt,
       noindex: builtin.noindex,
       canonicalPathOverride: builtin.canonicalPathOverride,
+      vars: builtin.vars,
       slug,
       locale: config.defaultLocale
     },
@@ -813,12 +1152,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, 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);
@@ -829,6 +1171,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,
@@ -838,14 +1188,16 @@ 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 createContentLoader(config, type, options = {}) {
   let cached = null;
   let signature = "";
   let lastCheck = 0;
+  let builtVersion = contentVersion;
   const contentDir = path.join(
     /* turbopackIgnore: true */
     config.rootDir,
@@ -853,18 +1205,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.statSync(f).mtimeMs);
+        newest = Math.max(newest, fs3.statSync(f).mtimeMs);
       } catch {
       }
     }
     let store = 0;
     try {
-      store = fs2.statSync(storePath).mtimeMs;
+      store = fs3.statSync(storePath).mtimeMs;
     } catch {
     }
     return `${files.length}:${newest}:${store}`;
@@ -910,16 +1278,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;
@@ -932,6 +1312,7 @@ function createContentLoader(config, type) {
     }
     lastCheck = Date.now();
     cached = build();
+    builtVersion = contentVersion;
     signature = isProd ? "" : computeSignature();
     return cached;
   };
@@ -1021,8 +1402,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])
   );
@@ -1039,12 +1423,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;
@@ -1057,7 +1441,7 @@ function buildRuntime(config, type, getRuntime) {
         load(),
         type,
         config.localeRouting,
-        config.localeFallbacks[locale] ?? []
+        config.localeFallbacks?.[locale] ?? []
       );
       if (result.document && type.path) {
         return {
@@ -1071,15 +1455,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) {
@@ -1158,7 +1542,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);
@@ -1167,8 +1551,15 @@ function createProject(config) {
     }
     return runtime;
   };
+  const inlineResolver = options.resolveInlineTokens ? createInlineResolver(config) : 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,
@@ -1261,10 +1652,10 @@ function redirectsFilePath(config, type) {
 }
 function loadTypeRedirectsFile(config, type) {
   const filePath = redirectsFilePath(config, type);
-  if (!fs2.existsSync(filePath)) return null;
+  if (!fs3.existsSync(filePath)) return null;
   let raw;
   try {
-    raw = JSON.parse(fs2.readFileSync(filePath, "utf8"));
+    raw = JSON.parse(fs3.readFileSync(filePath, "utf8"));
   } catch (error) {
     throw new Error(
       `${type.id}: failed to parse ${TYPE_REDIRECTS_FILENAME}: ${error instanceof Error ? error.message : String(error)}`
@@ -1420,7 +1811,7 @@ 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 });
   const scribe = {
     config,
     project,
@@ -1429,6 +1820,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) {