@llm-cms/core 0.0.1 → 0.0.2

package/src/node/eval-block.ts

@@ -0,0 +1,202 @@
+// packages/core/src/node/eval-block.ts
+// Sandbox-eval a convention `blocks/{Name}.tsx` blob (GitHub import).
+// `defineBlock` / `field` come from core; other imports are stubbed so the
+// SaaS never loads customer React, Next, or the host checkout.
+import { runInNewContext } from "node:vm";
+import { field } from "../fields";
+import { defineBlock, type BlockDef } from "../block";
+
+const SOURCE_EXT = /\.(ts|tsx|js|jsx|mjs)$/;
+const IGNORED = /(\.test\.|\.spec\.|\.d\.ts$|\.stories\.)/;
+const PASCAL = /^[A-Z][A-Za-z0-9]*$/;
+const CORE_IMPORT =
+  /^\s*import\s+\{([^}]+)\}\s+from\s+["'](@llm-cms\/core|@llm-cms\/next)["']\s*;?\s*$/gm;
+const TYPE_IMPORT = /^\s*import\s+type\s+[\s\S]*?from\s+["'][^"']+["']\s*;?\s*$/gm;
+const VALUE_IMPORT = /^\s*import\s+([\s\S]*?)\s+from\s+["'][^"']+["']\s*;?\s*$/gm;
+const USE_CLIENT = /^["']use client["'];?\s*$/gm;
+const ALLOWED_NAMES = new Set(["defineBlock", "field", "InferBlockProps"]);
+const FORBIDDEN = [
+  { re: /\brequire\s*\(/, name: "require" },
+  { re: /\bimport\s*\(/, name: "import" },
+  { re: /\bprocess\b/, name: "process" },
+  { re: /\bBun\b/, name: "Bun" },
+  { re: /\bDeno\b/, name: "Deno" },
+  { re: /\bglobalThis\b/, name: "globalThis" },
+  { re: /\bFunction\s*\(/, name: "Function" },
+  { re: /\beval\s*\(/, name: "eval" },
+];
+const EVAL_TIMEOUT_MS = 1000;
+
+function isBlockDef(value: unknown): value is BlockDef {
+  if (!value || typeof value !== "object") return false;
+  const m = value as Record<string, unknown>;
+  return typeof m.name === "string" && typeof m.fields === "object" && "component" in m;
+}
+
+/** True for a repo-relative `blocks/{Name}.tsx` (PascalCase stem). */
+export function isBlockSourcePath(
+  repoPath: string,
+  blocksDir = "blocks",
+): boolean {
+  const normalized = repoPath.split("\\").join("/");
+  const prefix = `${blocksDir.replace(/\/+$/, "")}/`;
+  if (!normalized.startsWith(prefix)) return false;
+  const name = normalized.slice(prefix.length);
+  if (!name || name.includes("/")) return false;
+  if (name.startsWith("_") || name.startsWith(".")) return false;
+  if (!SOURCE_EXT.test(name) || IGNORED.test(name)) return false;
+  return PASCAL.test(name.replace(SOURCE_EXT, ""));
+}
+
+function stemOf(repoPath: string): string {
+  const name = repoPath.split("\\").join("/").split("/").pop() ?? "";
+  return name.replace(SOURCE_EXT, "");
+}
+
+function identifierOf(part: string): string | null {
+  const trimmed = part.trim();
+  if (!trimmed || trimmed.startsWith("type ")) return null;
+  const aliased = trimmed.split(/\s+as\s+/);
+  const name = (aliased[1] ?? aliased[0] ?? "").trim();
+  return name || null;
+}
+
+function stubImportSpec(spec: string): string {
+  const stubs: string[] = [];
+  const named = spec.match(/\{([^}]*)\}/);
+  if (named) {
+    for (const part of named[1].split(",")) {
+      const id = identifierOf(part);
+      if (id) stubs.push(`var ${id} = function () { return null; };`);
+    }
+  }
+  const before = spec.split("{")[0] ?? "";
+  const defaultName = before.replace(/,\s*$/, "").trim();
+  if (defaultName.startsWith("*")) {
+    const as = defaultName.match(/as\s+(\w+)/);
+    if (as) stubs.push(`var ${as[1]} = {};`);
+  } else if (defaultName) {
+    stubs.push(`var ${defaultName} = function () { return null; };`);
+  }
+  return stubs.join("\n");
+}
+
+function rewriteSource(source: string): string {
+  let body = source.replace(USE_CLIENT, "");
+  body = body.replace(TYPE_IMPORT, "");
+  body = body.replace(CORE_IMPORT, (_full, specifiers: string) => {
+    for (const part of specifiers.split(",")) {
+      const raw = part.trim();
+      if (!raw) continue;
+      const name = raw.replace(/^type\s+/, "").split(/\s+as\s+/)[0]?.trim();
+      if (!name) continue;
+      if (!ALLOWED_NAMES.has(name)) {
+        throw new Error(`import "${name}" is not allowed from @llm-cms/core`);
+      }
+    }
+    return "";
+  });
+  body = body.replace(VALUE_IMPORT, (line) => {
+    const m = line.match(/^\s*import\s+([\s\S]*?)\s+from\s+["'][^"']+["']\s*;?\s*$/);
+    if (!m) throw new Error("import is not allowed");
+    return stubImportSpec(m[1]);
+  });
+  if (/^\s*import\b/m.test(body)) {
+    throw new Error("import is not allowed except defineBlock/field from @llm-cms/core");
+  }
+  if (!/\bexport\s+default\b/.test(body)) {
+    throw new Error("must export default defineBlock({ ... })");
+  }
+  const rewritten = stripNamedExports(body.replace(/\bexport\s+default\s+/, "return "));
+  if (/\bexport\b/.test(rewritten)) {
+    throw new Error("must export default defineBlock({ ... })");
+  }
+  return rewritten;
+}
+
+/** Host files also `export function Hero` for the Next composer map. */
+function stripNamedExports(source: string): string {
+  return source
+    .replace(/\bexport\s+\{[^}]*\}\s*;?/g, "")
+    .replace(/\bexport\s+(async\s+)?function\s+/g, "$1function ")
+    .replace(/\bexport\s+const\s+/g, "const ")
+    .replace(/\bexport\s+let\s+/g, "let ")
+    .replace(/\bexport\s+class\s+/g, "class ");
+}
+
+function assertNoForbidden(source: string): void {
+  for (const { re, name } of FORBIDDEN) {
+    if (re.test(source)) throw new Error(`${name} is not allowed in block files`);
+  }
+}
+
+function transpile(source: string): string {
+  const transpiler = new Bun.Transpiler({ loader: "tsx", target: "node" });
+  return transpiler.transformSync(source);
+}
+
+/** Evaluate one convention block file. `stem` must equal `block.name`. */
+export function evalBlockSource(source: string, stem: string): BlockDef {
+  const body = rewriteSource(source);
+  assertNoForbidden(body);
+  const wrapped = `(function () {\n${body}\n})()`;
+  const js = transpile(wrapped);
+  const sandbox = Object.create(null) as {
+    defineBlock: typeof defineBlock;
+    field: typeof field;
+    React: { createElement: (...args: unknown[]) => null; Fragment: string };
+    jsx: (...args: unknown[]) => null;
+    jsxs: (...args: unknown[]) => null;
+    jsxDEV: (...args: unknown[]) => null;
+  };
+  const el = () => null;
+  sandbox.defineBlock = defineBlock;
+  sandbox.field = field;
+  sandbox.React = { createElement: el, Fragment: "Fragment" };
+  sandbox.jsx = el;
+  sandbox.jsxs = el;
+  sandbox.jsxDEV = el;
+  Object.freeze(sandbox);
+
+  let result: unknown;
+  try {
+    result = runInNewContext(js, sandbox, {
+      timeout: EVAL_TIMEOUT_MS,
+      filename: `${stem}.js`,
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`block "${stem}" failed to evaluate: ${message}`);
+  }
+
+  if (!isBlockDef(result)) {
+    throw new Error("must export default defineBlock({ ... })");
+  }
+  if (result.name !== stem) {
+    throw new Error(
+      `defines name "${result.name}" but the file is named "${stem}"; rename one so they match`,
+    );
+  }
+  return result;
+}
+
+export function evalBlocksFromTree(
+  files: Array<{ path: string; source: string }>,
+  blocksDir = "blocks",
+): BlockDef[] {
+  const blocks: BlockDef[] = [];
+  const names = new Set<string>();
+  const sorted = files
+    .filter((f) => isBlockSourcePath(f.path, blocksDir))
+    .sort((a, b) => a.path.localeCompare(b.path));
+  for (const file of sorted) {
+    const stem = stemOf(file.path);
+    const block = evalBlockSource(file.source, stem);
+    if (names.has(block.name)) {
+      throw new Error(`duplicate block name "${block.name}" (${file.path})`);
+    }
+    names.add(block.name);
+    blocks.push(block);
+  }
+  return blocks;
+}

package/src/node/eval-model.ts

@@ -0,0 +1,143 @@
+// packages/core/src/node/eval-model.ts
+// Sandbox-eval a convention `models/{type}.ts` blob (GitHub import). Only
+// `defineModel` / `field` from @llm-cms/core or @llm-cms/next are in scope —
+// never import() the customer checkout.
+import { runInNewContext } from "node:vm";
+import { defineModel, type ModelDef } from "../model";
+import { field } from "../fields";
+
+const SOURCE_EXT = /\.(ts|tsx|js|jsx|mjs)$/;
+const IGNORED = /(\.test\.|\.spec\.|\.d\.ts$|\.stories\.)/;
+const ALLOWED_IMPORT = /^\s*import\s+\{([^}]+)\}\s+from\s+["'](@llm-cms\/core|@llm-cms\/next)["']\s*;?\s*$/gm;
+const ALLOWED_NAMES = new Set(["defineModel", "field"]);
+const FORBIDDEN = [
+  { re: /\brequire\s*\(/, name: "require" },
+  { re: /\bimport\s*\(/, name: "import" },
+  { re: /\bprocess\b/, name: "process" },
+  { re: /\bBun\b/, name: "Bun" },
+  { re: /\bDeno\b/, name: "Deno" },
+  { re: /\bglobalThis\b/, name: "globalThis" },
+  { re: /\bFunction\s*\(/, name: "Function" },
+  { re: /\beval\s*\(/, name: "eval" },
+];
+const EVAL_TIMEOUT_MS = 1000;
+
+function isModelDef(value: unknown): value is ModelDef {
+  if (!value || typeof value !== "object") return false;
+  const m = value as Record<string, unknown>;
+  return typeof m.type === "string" && typeof m.path === "string" && typeof m.fields === "object";
+}
+
+/** True for a repo-relative `models/{type}.ts` (flat folder, same filters as listModelFiles). */
+export function isModelSourcePath(repoPath: string, modelsDir = "models"): boolean {
+  const normalized = repoPath.split("\\").join("/");
+  const prefix = `${modelsDir.replace(/\/+$/, "")}/`;
+  if (!normalized.startsWith(prefix)) return false;
+  const name = normalized.slice(prefix.length);
+  if (!name || name.includes("/")) return false;
+  if (name.startsWith("_") || name.startsWith(".")) return false;
+  return SOURCE_EXT.test(name) && !IGNORED.test(name);
+}
+
+function stemOf(repoPath: string): string {
+  const name = repoPath.split("\\").join("/").split("/").pop() ?? "";
+  return name.replace(SOURCE_EXT, "");
+}
+
+function stripAllowedImports(source: string): string {
+  const names = new Set<string>();
+  const stripped = source.replace(ALLOWED_IMPORT, (_full, specifiers: string) => {
+    for (const part of specifiers.split(",")) {
+      const name = part.trim();
+      if (!name) continue;
+      if (/\bas\b/.test(name) || !ALLOWED_NAMES.has(name)) {
+        throw new Error(`import "${name}" is not allowed; only defineModel and field`);
+      }
+      names.add(name);
+    }
+    return "";
+  });
+  if (/^\s*import\b/m.test(stripped)) {
+    throw new Error("import is not allowed except defineModel/field from @llm-cms/core or @llm-cms/next");
+  }
+  return stripped;
+}
+
+function assertNoForbidden(source: string): void {
+  for (const { re, name } of FORBIDDEN) {
+    if (re.test(source)) throw new Error(`${name} is not allowed in model files`);
+  }
+}
+
+function rewriteDefaultExport(source: string): string {
+  if (!/\bexport\s+default\b/.test(source)) {
+    throw new Error("must export default defineModel({ ... })");
+  }
+  const rewritten = source.replace(/\bexport\s+default\s+/, "return ");
+  if (/\bexport\b/.test(rewritten)) {
+    throw new Error("must export default defineModel({ ... })");
+  }
+  return rewritten;
+}
+
+function transpile(source: string): string {
+  const transpiler = new Bun.Transpiler({ loader: "ts", target: "node" });
+  return transpiler.transformSync(source);
+}
+
+/**
+ * Evaluate one convention model file. `stem` is the file name without extension
+ * and must equal `model.type`.
+ */
+export function evalModelSource(source: string, stem: string): ModelDef {
+  const body = rewriteDefaultExport(stripAllowedImports(source));
+  assertNoForbidden(body);
+  const wrapped = `(function () {\n${body}\n})()`;
+  const js = transpile(wrapped);
+  const sandbox = Object.create(null) as { defineModel: typeof defineModel; field: typeof field };
+  sandbox.defineModel = defineModel;
+  sandbox.field = field;
+  Object.freeze(sandbox);
+
+  let result: unknown;
+  try {
+    result = runInNewContext(js, sandbox, {
+      timeout: EVAL_TIMEOUT_MS,
+      filename: `${stem}.js`,
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`model "${stem}" failed to evaluate: ${message}`);
+  }
+
+  if (!isModelDef(result)) {
+    throw new Error("must export default defineModel({ ... })");
+  }
+  if (result.type !== stem) {
+    throw new Error(
+      `defines type "${result.type}" but the file is named "${stem}"; rename one so they match`,
+    );
+  }
+  return result;
+}
+
+export function evalModelsFromTree(
+  files: Array<{ path: string; source: string }>,
+  modelsDir = "models",
+): ModelDef[] {
+  const models: ModelDef[] = [];
+  const types = new Set<string>();
+  const sorted = files
+    .filter((f) => isModelSourcePath(f.path, modelsDir))
+    .sort((a, b) => a.path.localeCompare(b.path));
+  for (const file of sorted) {
+    const stem = stemOf(file.path);
+    const model = evalModelSource(file.source, stem);
+    if (types.has(model.type)) {
+      throw new Error(`duplicate model type "${model.type}" (${file.path})`);
+    }
+    types.add(model.type);
+    models.push(model);
+  }
+  return models;
+}

package/src/node/fs-loader.ts

@@ -3,7 +3,8 @@ import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import {
   matchAnyModelPath,
-  parseMdx,
+  modelFormat,
+  parseDoc,
   repoPathFromModel,
   type ModelSnapshot,
 } from "../index";
@@ -11,7 +12,13 @@ import type { LlmcmsDoc, LlmcmsDocSummary } from "../doc";
 
 const SKIP_DIRS = new Set(["node_modules", ".next", ".git"]);
 
+const CONTENT_EXT = /\.(mdx|json)$/;
+
 export async function walkMdxFiles(rootDir: string): Promise<string[]> {
+  return walkContentFiles(rootDir);
+}
+
+export async function walkContentFiles(rootDir: string): Promise<string[]> {
   const out: string[] = [];
 
   async function walk(dir: string) {
@@ -26,7 +33,7 @@ export async function walkMdxFiles(rootDir: string): Promise<string[]> {
       const full = path.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
-      } else if (entry.isFile() && entry.name.endsWith(".mdx")) {
+      } else if (entry.isFile() && CONTENT_EXT.test(entry.name)) {
         out.push(full);
       }
     }
@@ -40,7 +47,7 @@ export async function listDocsFromFs(
   siteRoot: string,
   models: ModelSnapshot[],
 ): Promise<LlmcmsDocSummary[]> {
-  const files = await walkMdxFiles(siteRoot);
+  const files = await walkContentFiles(siteRoot);
   const docs: LlmcmsDocSummary[] = [];
   for (const full of files) {
     const rel = path.relative(siteRoot, full).split(path.sep).join("/");
@@ -76,7 +83,7 @@ export async function getDocFromFs(
   } catch {
     return null;
   }
-  const parsed = parseMdx(raw);
+  const parsed = parseDoc(raw, modelFormat(model));
   return {
     locale,
     type,

package/src/node/generate.ts

@@ -1,11 +1,11 @@
 // packages/core/src/node/generate.ts
-// Writes the `.llmcms/` registry: a models barrel + typed `cms` client, and a
-// blocks barrel. Pure filesystem (no TS import) so it can run inside
-// next.config and on every file change in dev.
+// Writes the `.llmcms/` registry: a models barrel + typed `cms` client, a
+// blocks barrel, and an MDX components barrel. Pure filesystem (no TS import)
+// so it can run inside next.config and on every file change in dev.
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { DEFAULT_DIRS } from "../config";
-import { listBlockFiles, listModelFiles, type BlockFile, type ModelFile } from "./discover";
+import { listBlockFiles, listMdxFiles, listModelFiles, type BlockFile, type ModelFile } from "./discover";
 
 // Re-exported so `@llm-cms/core/generate` is a self-sufficient, dependency-light
 // entry for bundler-side code (no zod / yaml pulled in).
@@ -22,6 +22,7 @@ export type GenerateOptions = {
   outDir?: string;
   modelsDir?: string;
   blocksDir?: string;
+  mdxDir?: string;
   /** Module that exports `createLlmcms`. Auto-detected from package.json when omitted. */
   sdk?: string;
   /** Write to disk. Default: true. `false` only renders (used by the bundler loader). */
@@ -47,7 +48,9 @@ export type GenerateResult = {
   changed: string[];
   models: ModelFile[];
   blocks: BlockFile[];
+  mdx: BlockFile[];
   skippedBlocks: string[];
+  skippedMdx: string[];
   /** Absolute path of `llmcms.config.*` when present. */
   configFile: string | null;
 };
@@ -83,6 +86,7 @@ export function detectSdk(root: string): string {
 export function renderModelsBarrel(input: {
   outDir: string;
   models: ModelFile[];
+  blocks?: BlockFile[];
   configFile: string | null;
   sdk: string;
 }): string {
@@ -95,22 +99,44 @@ export function renderModelsBarrel(input: {
   for (const m of input.models) {
     lines.push(`import ${m.importName} from "${importSpecifier(input.outDir, m.file)}";`);
   }
+  const blocks = input.blocks ?? [];
+  for (const b of blocks) {
+    lines.push(`import ${b.name} from "${importSpecifier(input.outDir, b.file)}";`);
+  }
   lines.push("");
   lines.push(`export const models = [${input.models.map((m) => m.importName).join(", ")}] as const;`);
   lines.push("export type Models = typeof models;");
   lines.push("");
+  lines.push(
+    `export const blocks = [${blocks.map((b) => b.name).join(", ")}] as const;`,
+  );
+  lines.push("");
   lines.push("/** Typed content client: cms.query.{type}, cms.getDoc, cms.listDocs. */");
-  lines.push("export const cms = createLlmcms({ ...config, models });");
+  lines.push("export const cms = createLlmcms({ ...config, models, blocks });");
+  return `${lines.join("\n")}\n`;
+}
+
+export function renderMdxBarrel(input: { outDir: string; mdx: BlockFile[] }): string {
+  const lines = [GENERATED_HEADER];
+  for (const b of input.mdx) {
+    lines.push(`import ${b.name} from "${importSpecifier(input.outDir, b.file)}";`);
+  }
+  lines.push("");
+  lines.push("/** MDX component map: <Hero /> in content resolves to mdx/Hero.tsx. */");
+  const names = input.mdx.map((b) => b.name).join(", ");
+  lines.push(`export const components = ${names ? `{ ${names} }` : "{}"};`);
   return `${lines.join("\n")}\n`;
 }
 
 export function renderBlocksBarrel(input: { outDir: string; blocks: BlockFile[] }): string {
   const lines = [GENERATED_HEADER];
   for (const b of input.blocks) {
-    lines.push(`import ${b.name} from "${importSpecifier(input.outDir, b.file)}";`);
+    lines.push(`import { ${b.name} } from "${importSpecifier(input.outDir, b.file)}";`);
   }
   lines.push("");
-  lines.push("/** MDX component map: <Hero /> in content resolves to blocks/Hero.tsx. */");
+  // Named imports, not `def.component`: Next cannot resolve a nested property
+  // on a `"use client"` module from a Server Component.
+  lines.push("/** Composer map: JSON `{ type: \"Hero\" }` resolves to blocks/Hero.tsx. */");
   const names = input.blocks.map((b) => b.name).join(", ");
   lines.push(`export const blocks = ${names ? `{ ${names} }` : "{}"};`);
   return `${lines.join("\n")}\n`;
@@ -121,20 +147,28 @@ function differsOnDisk(file: string, content: string): boolean {
 }
 
 /** Registry file names inside the out dir. */
-export const REGISTRY_FILES = ["index.ts", "blocks.ts"] as const;
+export const REGISTRY_FILES = ["index.ts", "blocks.ts", "mdx.ts"] as const;
 
 export function generate(options: GenerateOptions): GenerateResult {
   const root = path.resolve(options.root);
   const outDir = path.resolve(root, options.outDir ?? DEFAULT_OUT_DIR);
   const models = listModelFiles(root, options.modelsDir ?? DEFAULT_DIRS.models);
-  const { blocks, skipped } = listBlockFiles(root, options.blocksDir ?? DEFAULT_DIRS.blocks);
+  const { blocks, skipped: skippedBlocks } = listBlockFiles(
+    root,
+    options.blocksDir ?? DEFAULT_DIRS.blocks,
+  );
+  const { blocks: mdx, skipped: skippedMdx } = listMdxFiles(
+    root,
+    options.mdxDir ?? DEFAULT_DIRS.mdx,
+  );
   const sdk = options.sdk ?? detectSdk(root);
   const configFile = findConfigFile(root);
   const write = options.write ?? true;
 
   const rendered: Record<(typeof REGISTRY_FILES)[number], string> = {
-    "index.ts": renderModelsBarrel({ outDir, models, configFile, sdk }),
+    "index.ts": renderModelsBarrel({ outDir, models, blocks, configFile, sdk }),
     "blocks.ts": renderBlocksBarrel({ outDir, blocks }),
+    "mdx.ts": renderMdxBarrel({ outDir, mdx }),
   };
   const outputs: GeneratedFile[] = REGISTRY_FILES.map((name) => {
     const file = path.join(outDir, name);
@@ -152,7 +186,9 @@ export function generate(options: GenerateOptions): GenerateResult {
     changed: outputs.filter((o) => o.changed).map((o) => o.rel),
     models,
     blocks,
-    skippedBlocks: skipped,
+    mdx,
+    skippedBlocks,
+    skippedMdx,
     configFile,
   };
 }

package/src/node/index.ts

@@ -4,19 +4,28 @@
 // `@llm-cms/core/preview` instead.
 export { createLlmcms } from "./create-llmcms";
 export type { CreateLlmcmsOptions, LlmcmsClient } from "./create-llmcms";
-export { getDocFromFs, listDocsFromFs, walkMdxFiles } from "./fs-loader";
+export { getDocFromFs, listDocsFromFs, walkMdxFiles, walkContentFiles } from "./fs-loader";
 export {
   discoverModels,
+  discoverBlocks,
   listBlockFiles,
+  listMdxFiles,
   listModelFiles,
   toIdentifier,
 } from "./discover";
 export type { BlockFile, ModelFile } from "./discover";
+export { evalModelSource, evalModelsFromTree, isModelSourcePath } from "./eval-model";
+export {
+  evalBlockSource,
+  evalBlocksFromTree,
+  isBlockSourcePath,
+} from "./eval-block";
 export {
   detectSdk,
   findConfigFile,
   generate,
   renderBlocksBarrel,
+  renderMdxBarrel,
   renderModelsBarrel,
   DEFAULT_OUT_DIR,
   REGISTRY_FILES,

package/src/path.ts

@@ -32,10 +32,12 @@ export function matchModelPath(
   const re = compilePathPattern(model.path);
   const m = re.exec(normalized);
   if (!m?.groups?.locale || !m.groups.slug) return null;
-  // Strip trailing .mdx from slug if the template baked the extension into the capture.
+  // Strip trailing extension from slug if the template baked it into the capture.
   let slug = m.groups.slug;
-  if (model.path.endsWith(".mdx") && slug.endsWith(".mdx")) {
-    slug = slug.slice(0, -".mdx".length);
+  const ext = contentExtFromPath(model.path);
+  const suffix = `.${ext}`;
+  if (model.path.endsWith(suffix) && slug.endsWith(suffix)) {
+    slug = slug.slice(0, -suffix.length);
   }
   if (!slug) return null;
   return { locale: m.groups.locale, slug, type: model.type };
@@ -52,6 +54,19 @@ export function matchAnyModelPath(
   return null;
 }
 
+export function contentExtFromPath(modelPath: string): string {
+  const m = /\.([a-z0-9]+)$/i.exec(modelPath);
+  return m?.[1]?.toLowerCase() ?? "mdx";
+}
+
+export function contentExtForType(
+  models: Array<Pick<ModelSnapshot, "type" | "path">> | undefined,
+  type: string,
+): string {
+  const model = models?.find((m) => m.type === type);
+  return model ? contentExtFromPath(model.path) : "mdx";
+}
+
 export function repoPathFromModel(
   model: Pick<ModelSnapshot, "path">,
   locale: string,
@@ -106,8 +121,9 @@ export function s3HeadKey(
   locale: string,
   type: string,
   slug: string,
+  ext = "mdx",
 ): string {
-  return `${s3HeadPrefix(workspaceId, branch)}${locale}/${type}/${slug}.mdx`;
+  return `${s3HeadPrefix(workspaceId, branch)}${locale}/${type}/${slug}.${ext}`;
 }
 
 export function s3TreeKey(
@@ -117,8 +133,9 @@ export function s3TreeKey(
   locale: string,
   type: string,
   slug: string,
+  ext = "mdx",
 ): string {
-  return `${s3TreePrefix(workspaceId, branch, userId)}${locale}/${type}/${slug}.mdx`;
+  return `${s3TreePrefix(workspaceId, branch, userId)}${locale}/${type}/${slug}.${ext}`;
 }
 
 /** HEAD blob sha for conflict checks. */
@@ -151,7 +168,7 @@ export function parseS3ContentKey(
   if (!key.startsWith(prefix)) return null;
   const rest = key.slice(prefix.length);
 
-  const head = /^([^/]+)\/head\/([^/]+)\/([^/]+)\/(.+)\.mdx$/.exec(rest);
+  const head = /^([^/]+)\/head\/([^/]+)\/([^/]+)\/(.+)\.(mdx|json)$/.exec(rest);
   if (head) {
     return {
       branch: decodeGitBranch(head[1]!),
@@ -164,7 +181,7 @@ export function parseS3ContentKey(
   }
 
   const tree =
-    /^([^/]+)\/trees\/([^/]+)\/([^/]+)\/([^/]+)\/(.+)\.mdx$/.exec(rest);
+    /^([^/]+)\/trees\/([^/]+)\/([^/]+)\/([^/]+)\/(.+)\.(mdx|json)$/.exec(rest);
   if (tree) {
     return {
       branch: decodeGitBranch(tree[1]!),

package/src/sync-schema.ts

@@ -4,6 +4,7 @@ import {
   type ModelDef,
   type ModelSnapshot,
 } from "./model";
+import type { BlockDef } from "./block";
 
 export function detectGitBranch(
   env: Record<string, string | undefined> = process.env,
@@ -20,13 +21,14 @@ export type SyncSchemaOptions = {
   workspaceId: string;
   hostToken: string;
   models: Array<ModelDef | ModelSnapshot>;
+  blocks?: BlockDef[];
   branch?: string;
   siteUrl?: string;
 };
 
 export async function syncSchema(options: SyncSchemaOptions): Promise<void> {
   const branch = options.branch ?? detectGitBranch() ?? "main";
-  const payload = serializeSchema(options.models as ModelDef[]);
+  const payload = serializeSchema(options.models as ModelDef[], options.blocks);
   const body: { payload: ReturnType<typeof serializeSchema>; branch: string; siteUrl?: string } = {
     payload,
     branch,