@backmatter/core 0.0.27 → 0.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backmatter/core",
-  "version": "0.0.27",
+  "version": "0.0.28",
   "description": "Experimental Backmatter SDK. APIs will break. Not ready for production.",
   "type": "module",
   "publishConfig": {

package/src/api-loader.ts

@@ -1,11 +1,9 @@
 // packages/core/src/api-loader.ts
 import type { BackmatterDoc, BackmatterDocSummary } from "./doc";
-import { encodeDocLocale } from "./path";
 
 export type PublicDocsQuery = {
   branch?: string;
   type?: string;
-  locale?: string;
   /** When set, Next Data Cache uses these tags instead of `cache: "no-store"`. */
   tags?: string[];
 };
@@ -31,7 +29,6 @@ function publicDocsUrl(
   );
   if (query.branch) url.searchParams.set("branch", query.branch);
   if (query.type) url.searchParams.set("type", query.type);
-  if (query.locale) url.searchParams.set("locale", query.locale);
   return url.toString();
 }
 
@@ -55,13 +52,12 @@ export async function getDocFromApi(
   apiUrl: string,
   workspaceId: string,
   contentToken: string | undefined,
-  locale: string,
   type: string,
   slug: string,
   query: Pick<PublicDocsQuery, "branch" | "tags"> = {},
 ): Promise<BackmatterDoc | null> {
   const res = await fetch(
-    publicDocsUrl(apiUrl, workspaceId, `/${encodeDocLocale(locale)}/${type}/${slug}`, query),
+    publicDocsUrl(apiUrl, workspaceId, `/${type}/${slug}`, query),
     fetchInit(contentToken, query.tags),
   );
   if (res.status === 404) return null;

package/src/config.ts

@@ -48,16 +48,11 @@ export type BackmatterConfig = {
   siteUrl?: string;
   /** Site root for filesystem mode. Default: process.cwd(). */
   siteRoot?: string;
-  /** Locales the catch-all route accepts in `{locale}`. Unset → any segment. */
-  locales?: readonly string[];
-  /** Locale used by routes without a `{locale}` placeholder. Default: "en". */
-  defaultLocale?: string;
   dirs?: BackmatterDirs;
   devBar?: DevBarHostConfig;
 };
 
-export type ResolvedConfig = Omit<BackmatterConfig, "dirs" | "defaultLocale"> & {
-  defaultLocale: string;
+export type ResolvedConfig = Omit<BackmatterConfig, "dirs"> & {
   dirs: Required<BackmatterDirs>;
 };
 
@@ -70,7 +65,6 @@ export const DEFAULT_DIRS: Required<BackmatterDirs> = {
   objects: "objects",
   sources: "sources",
 };
-export const DEFAULT_LOCALE = "en";
 export const CLOUD_API_URL = "https://api.backmatter.app";
 export const CLOUD_DASHBOARD_URL = "https://dash.backmatter.app";
 export const LOCAL_DASHBOARD_URL = "http://localhost:5173";
@@ -189,12 +183,6 @@ export function detectSiteUrl(
 
 /** Identity helper that gives `backmatter.config.ts` a typed default export. */
 export function defineConfig(config: BackmatterConfig): BackmatterConfig {
-  if (config.defaultLocale !== undefined && !config.defaultLocale) {
-    throw new Error("config.defaultLocale must be a non-empty string");
-  }
-  if (config.locales && config.defaultLocale && !config.locales.includes(config.defaultLocale)) {
-    throw new Error(`config.defaultLocale "${config.defaultLocale}" is not in config.locales`);
-  }
   return config;
 }
 
@@ -218,8 +206,6 @@ export function resolveConfig(
     branch: config.branch?.trim() || detectGitBranch(env) || undefined,
     siteUrl: detectSiteUrl(config, env),
     siteRoot: config.siteRoot,
-    locales: config.locales,
-    defaultLocale: config.defaultLocale ?? DEFAULT_LOCALE,
     devBar: config.devBar,
     dirs: {
       models: config.dirs?.models ?? DEFAULT_DIRS.models,

package/src/content-committed.ts

@@ -10,7 +10,6 @@ export const BACKMATTER_REVALIDATE_PATH = "/api/backmatter/revalidate";
 export const BACKMATTER_CACHE_TAG = "backmatter";
 
 export type ContentCommittedDoc = {
-  locale: string;
   type: string;
   slug: string;
 };
@@ -29,11 +28,8 @@ export function revalidateUrl(siteUrl: string): string {
   return `${siteUrl.replace(/\/$/, "")}${BACKMATTER_REVALIDATE_PATH}`;
 }
 
-export function contentCacheTags(locale: string, type: string, slug: string): string[] {
-  const identity = locale
-    ? `backmatter:${locale}:${type}:${slug}`
-    : `backmatter:${type}:${slug}`;
-  return [BACKMATTER_CACHE_TAG, `backmatter:${type}`, identity];
+export function contentCacheTags(type: string, slug: string): string[] {
+  return [BACKMATTER_CACHE_TAG, `backmatter:${type}`, `backmatter:${type}:${slug}`];
 }
 
 export function listCacheTags(type?: string): string[] {
@@ -49,7 +45,7 @@ export function revalidateTagsForCommit(event: Pick<ContentCommittedEvent, "docs
   if (event.full) return [BACKMATTER_CACHE_TAG];
   const tags = new Set<string>();
   for (const doc of event.docs ?? []) {
-    for (const tag of contentCacheTags(doc.locale, doc.type, doc.slug)) {
+    for (const tag of contentCacheTags(doc.type, doc.slug)) {
       if (tag !== BACKMATTER_CACHE_TAG) tags.add(tag);
     }
   }
@@ -67,7 +63,7 @@ export function pathsForCommittedDocs(
   for (const doc of docs) {
     const model = byType.get(doc.type);
     if (!model) continue;
-    const path = routeFor(model, doc.locale, doc.slug);
+    const path = routeFor(model, doc.slug);
     if (!path) continue;
     if (seen.has(path)) continue;
     seen.add(path);

package/src/doc-ref.ts

@@ -1,6 +1,6 @@
+// packages/core/src/doc-ref.ts
 export type DocRef = {
   workspaceId: string;
-  locale: string;
   type: string;
   slug: string;
 };
@@ -15,12 +15,8 @@ export function parseDocRef(input: unknown): DocRef {
       throw new Error(`docRef.${key} is required`);
     }
   }
-  if (typeof value.locale !== "string") {
-    throw new Error("docRef.locale is required");
-  }
   return {
     workspaceId: value.workspaceId as string,
-    locale: value.locale as string,
     type: value.type as string,
     slug: value.slug as string,
   };
@@ -28,7 +24,5 @@ export function parseDocRef(input: unknown): DocRef {
 
 /** Relative content path (no workspace prefix) used under head/ and trees/{userId}/. */
 export function docRefPath(ref: DocRef): string {
-  return ref.locale
-    ? `${ref.locale}/${ref.type}/${ref.slug}`
-    : `${ref.type}/${ref.slug}`;
+  return `${ref.type}/${ref.slug}`;
 }

package/src/doc.ts

@@ -1,7 +1,6 @@
 // packages/core/src/doc.ts
 
 export type BackmatterDocSummary = {
-  locale: string;
   type: string;
   slug: string;
   /** Card-level fields when the loader already parsed the file. */
@@ -9,7 +8,6 @@ export type BackmatterDocSummary = {
 };
 
 export type BackmatterDoc = {
-  locale: string;
   type: string;
   slug: string;
   /** `head` = committed on the branch; `tree` = the caller's uncommitted working copy. */

package/src/fields.ts

@@ -2,7 +2,6 @@
 
 export type FieldKind =
   | "text"
-  | "locale"
   | "image"
   | "media"
   | "relation"
@@ -77,7 +76,6 @@ function composite<K extends "object" | "array", R extends boolean>(
 
 export const field = {
   text: <const R extends boolean = false>(opts?: Opts<R>) => base("text", opts),
-  locale: <const R extends boolean = false>(opts?: Opts<R>) => base("locale", opts),
   image: <const R extends boolean = false>(opts?: Opts<R>) => base("image", opts),
   media: <const R extends boolean = false>(opts?: Opts<R>) => base("media", opts),
   number: <const R extends boolean = false>(opts?: Opts<R>) => base("number", opts),
@@ -117,7 +115,6 @@ export function parseFieldSnapshot(input: unknown): FieldSnapshot {
   const kind = value.kind;
   const allowed: FieldKind[] = [
     "text",
-    "locale",
     "image",
     "media",
     "relation",

package/src/index.ts

@@ -75,13 +75,12 @@ export {
   resolveDevBarApiUrl,
   resolveDashboardUrl,
   DEFAULT_DIRS,
-  DEFAULT_LOCALE,
   CLOUD_API_URL,
   CLOUD_DASHBOARD_URL,
   LOCAL_DASHBOARD_URL,
 } from "./config";
 
-export type { RouteMatch, RouteModel, MatchRouteOptions } from "./routes";
+export type { RouteMatch, RouteModel } from "./routes";
 export {
   DEFAULT_ROUTE,
   compileRoutePattern,
@@ -110,9 +109,6 @@ export {
   repoPathFromModel,
   contentExtFromPath,
   contentExtForType,
-  EMPTY_LOCALE_SEGMENT,
-  encodeDocLocale,
-  decodeDocLocale,
   encodeGitBranch,
   decodeGitBranch,
   s3HeadKey,

package/src/model.ts

@@ -13,17 +13,16 @@ import type { DocFormat } from "./doc-format";
 
 export type ModelDef = {
   type: string;
-  /** Repo-relative path template, e.g. content/{locale}/blog/{slug}.mdx */
+  /** Repo-relative path template, e.g. content/blog/{slug}.mdx */
   path: string;
   /**
    * URL template for the host catch-all route, e.g. "/blog/{slug}".
-   * Defaults to "/{locale}/{type}/{slug}" when omitted (see routes.ts).
+   * Defaults to "/{type}/{slug}" when omitted (see routes.ts).
    * `false` excludes the model from the catch-all. Singletons default to `false`.
    */
   route?: string | false;
   /**
-   * At most one document for each identity the path allows (one file, or one
-   * file per `{locale}` when that placeholder is present).
+   * At most one document for each identity the path allows.
    */
   singleton?: boolean;
   /** File format. Default `"mdx"`. `"page"` stores JSON with a blocks array. */
@@ -79,8 +78,8 @@ export function resolveTemplateSlug(
 }
 
 /** Default repo path when a model does not declare one. */
-export const DEFAULT_MODEL_PATH = "content/{locale}/{type}/{slug}.mdx";
-export const DEFAULT_PAGE_PATH = "content/{locale}/{type}/{slug}.json";
+export const DEFAULT_MODEL_PATH = "content/{type}/{slug}.mdx";
+export const DEFAULT_PAGE_PATH = "content/{type}/{slug}.json";
 
 export function defaultModelPath(type: string, format: DocFormat = "mdx"): string {
   const template = format === "page" ? DEFAULT_PAGE_PATH : DEFAULT_MODEL_PATH;
@@ -103,6 +102,9 @@ export type ModelSnapshot = {
 export const IMPLICIT_SINGLETON_SLUG = "index";
 
 export function assertModelPath(path: string, singleton: boolean, label = "model.path"): void {
+  if (path.includes("{locale}")) {
+    throw new Error(`${label} must not contain {locale}`);
+  }
   if (!singleton && !path.includes("{slug}")) {
     throw new Error(`${label} must include {slug}`);
   }
@@ -117,6 +119,9 @@ export function assertModelRoute(
   if (typeof route !== "string" || !route.startsWith("/")) {
     throw new Error(`${label} must start with "/"`);
   }
+  if (route.includes("{locale}")) {
+    throw new Error(`${label} must not contain {locale}`);
+  }
   if (!singleton && !route.includes("{slug}")) {
     throw new Error(`${label} must include {slug}`);
   }
@@ -140,7 +145,7 @@ type WithTemplate<D extends ModelInput> = D extends { external: true }
 
 /**
  * Validates the definition at runtime and preserves its literal types.
- * `path` defaults to `content/{locale}/{type}/{slug}.mdx`.
+ * `path` defaults to `content/{type}/{slug}.mdx`.
  */
 export function defineModel<const D extends ModelInput>(def: D): WithTemplate<WithPath<D>> {
   if (!def.type || typeof def.type !== "string") {

package/src/node/cli.ts

@@ -138,7 +138,7 @@ export async function loadModels(root: string, modelsPath?: string): Promise<Mod
 
 /**
  * Static directory roots the models' path templates live under, e.g.
- * `content/{locale}/blog/{slug}.mdx` → `content`. Roots that are sub-paths of
+ * `content/en/blog/{slug}.mdx` → `content/en`. Roots that are sub-paths of
  * another root are dropped; a template with no static leading segment yields ".".
  */
 export function contentRoots(models: ModelSnapshot[]): string[] {
@@ -257,13 +257,11 @@ import { defineConfig } from "${from}";
 
 // General settings only. Models live in models/*.ts, composer blocks in
 // blocks/*.tsx, in-content blocks in richtext/*.tsx, MDX tags in mdx/*.tsx,
-// and content in content/{locale}/{type}/{slug}.{mdx,json} — all discovered
-// automatically.
+// and content under each model's path template — all discovered automatically.
 // Set workspaceId from General settings (not an env var).
 // API URL defaults to https://api.backmatter.app in production; tokens stay env.
 export default defineConfig({
   // workspaceId: "ws_…",
-  defaultLocale: "en",
 });
 `;
 }

package/src/node/create-backmatter.ts

@@ -36,13 +36,8 @@ export type CreateBackmatterOptions<Models extends readonly ModelDef[] = readonl
 export type BackmatterClient<Models extends readonly ModelDef[] = readonly ModelDef[]> = {
   listDocs: (filter?: {
     type?: string;
-    locale?: string;
   }) => Promise<BackmatterDocSummary[]>;
-  getDoc: (
-    locale: string,
-    type: string,
-    slug: string,
-  ) => Promise<BackmatterDoc | null>;
+  getDoc: (type: string, slug: string) => Promise<BackmatterDoc | null>;
   /** Typed access keyed by model.type: cms.query.blog.get / findMany */
   query: Query<Models>;
   /** The registered models, e.g. for route matching. */
@@ -109,26 +104,24 @@ export function createBackmatter<const Models extends readonly ModelDef[]>(
         ? await listDocsFromApi(apiUrl!, workspaceId!, contentToken, {
             branch,
             type: filter?.type,
-            locale: filter?.locale,
             tags: taggedApiFetch ? listCacheTags(filter?.type) : undefined,
           })
         : await listDocsFromFs(siteRoot, models);
 
       return docs.filter((d) => {
         if (filter?.type && d.type !== filter.type) return false;
-        if (filter?.locale && d.locale !== filter.locale) return false;
         return true;
       });
     },
 
-    async getDoc(locale, type, slug) {
+    async getDoc(type, slug) {
       if (useApi) {
-        return getDocFromApi(apiUrl!, workspaceId!, contentToken, locale, type, slug, {
+        return getDocFromApi(apiUrl!, workspaceId!, contentToken, type, slug, {
           branch,
-          tags: taggedApiFetch ? contentCacheTags(locale, type, slug) : undefined,
+          tags: taggedApiFetch ? contentCacheTags(type, slug) : undefined,
         });
       }
-      return getDocFromFs(siteRoot, models, locale, type, slug);
+      return getDocFromFs(siteRoot, models, type, slug);
     },
   };
 

package/src/node/fs-loader.ts

@@ -63,15 +63,14 @@ export async function listDocsFromFs(
       }
     }
     docs.push({
-      locale: hit.locale ?? "",
       type: hit.type,
       slug: hit.slug,
       frontmatter,
     });
   }
   return docs.sort((a, b) => {
-    const ak = `${a.locale}/${a.type}/${a.slug}`;
-    const bk = `${b.locale}/${b.type}/${b.slug}`;
+    const ak = `${a.type}/${a.slug}`;
+    const bk = `${b.type}/${b.slug}`;
     return ak.localeCompare(bk);
   });
 }
@@ -79,13 +78,12 @@ export async function listDocsFromFs(
 export async function getDocFromFs(
   siteRoot: string,
   models: ModelSnapshot[],
-  locale: string,
   type: string,
   slug: string,
 ): Promise<BackmatterDoc | null> {
   const model = models.find((m) => m.type === type);
   if (!model) return null;
-  const rel = repoPathFromModel(model, locale, slug);
+  const rel = repoPathFromModel(model, slug);
   const full = path.join(siteRoot, rel);
   let raw: string;
   try {
@@ -95,7 +93,6 @@ export async function getDocFromFs(
   }
   const parsed = parseDoc(raw, modelFormat(model));
   return {
-    locale,
     type,
     slug,
     source: "head",

package/src/node/generate.ts

@@ -105,27 +105,27 @@ function renderCachedCmsClient(): string[] {
   return [
     "const raw = createBackmatter({ ...config, models, sync: false });",
     "",
-    "async function cachedGetDoc(locale: string, type: string, slug: string) {",
+    "async function cachedGetDoc(type: string, slug: string) {",
     '  "use cache";',
     '  cacheLife("hours");',
-    "  cacheTag(...contentCacheTags(locale, type, slug));",
-    "  return raw.getDoc(locale, type, slug);",
+    "  cacheTag(...contentCacheTags(type, slug));",
+    "  return raw.getDoc(type, slug);",
     "}",
     "",
-    "async function cachedListDocs(filter?: { type?: string; locale?: string }) {",
+    "async function cachedListDocs(filter?: { type?: string }) {",
     '  "use cache";',
     '  cacheLife("hours");',
     "  cacheTag(...listCacheTags(filter?.type));",
     "  return raw.listDocs(filter);",
     "}",
     "",
-    "async function getDoc(locale: string, type: string, slug: string) {",
+    "async function getDoc(type: string, slug: string) {",
     "  const preview = currentPreviewContent();",
-    "  if (preview) return preview.getDoc(locale, type, slug);",
-    "  return cachedGetDoc(locale, type, slug);",
+    "  if (preview) return preview.getDoc(type, slug);",
+    "  return cachedGetDoc(type, slug);",
     "}",
     "",
-    "async function listDocs(filter?: { type?: string; locale?: string }) {",
+    "async function listDocs(filter?: { type?: string }) {",
     "  const preview = currentPreviewContent();",
     "  if (preview) return preview.listDocs(filter);",
     "  return cachedListDocs(filter);",

package/src/page-nav.ts

@@ -2,7 +2,6 @@
 import { isRoutable, routeFor, type RouteModel } from "./routes";
 
 export type PageNavDoc = {
-  locale: string;
   type: string;
   slug: string;
 };
@@ -21,22 +20,19 @@ export function pageNavItems(input: {
   current: PageNavDoc | null;
 }): PageNavItem[] {
   const byType = new Map(input.models.map((model) => [model.type, model]));
-  const locales = new Set(input.docs.map((doc) => doc.locale));
-  const showLocale = locales.size > 1;
   const items: PageNavItem[] = [];
   for (const doc of input.docs) {
     const model = byType.get(doc.type);
     if (!model || !isRoutable(model)) continue;
-    const href = routeFor(model, doc.locale, doc.slug);
+    const href = routeFor(model, doc.slug);
     if (!href) continue;
     const name = `${doc.type}/${doc.slug}`;
     items.push({
-      key: `${doc.locale}/${doc.type}/${doc.slug}`,
-      label: showLocale ? `${name} · ${doc.locale}` : name,
+      key: `${doc.type}/${doc.slug}`,
+      label: name,
       href,
       current: Boolean(
         input.current &&
-          input.current.locale === doc.locale &&
           input.current.type === doc.type &&
           input.current.slug === doc.slug,
       ),

package/src/path.ts

@@ -2,7 +2,6 @@
 import { IMPLICIT_SINGLETON_SLUG, type ModelSnapshot } from "./model";
 
 export type PathMatch = {
-  locale?: string;
   slug: string;
   type: string;
 };
@@ -11,13 +10,15 @@ function escapeRegex(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-/** Compile a model path template into a regex with named locale/slug captures. */
+/** Compile a model path template into a regex with a named slug capture. */
 export function compilePathPattern(template: string): RegExp {
-  const parts = template.split(/(\{locale\}|\{slug\})/g);
+  if (template.includes("{locale}")) {
+    throw new Error("model.path must not contain {locale}");
+  }
+  const parts = template.split(/(\{slug\})/g);
   let pattern = "^";
   for (const part of parts) {
-    if (part === "{locale}") pattern += "(?<locale>[^/]+)";
-    else if (part === "{slug}") pattern += "(?<slug>[^/]+?)";
+    if (part === "{slug}") pattern += "(?<slug>[^/]+?)";
     else pattern += escapeRegex(part);
   }
   pattern += "$";
@@ -32,11 +33,8 @@ export function matchModelPath(
   const re = compilePathPattern(model.path);
   const m = re.exec(normalized);
   if (!m) return null;
-  const hasLocale = model.path.includes("{locale}");
   const hasSlug = model.path.includes("{slug}");
-  if (hasLocale && !m.groups?.locale) return null;
   if (hasSlug && !m.groups?.slug) return null;
-  // Strip trailing extension from slug if the template baked it into the capture.
   let slug = hasSlug ? m.groups!.slug! : IMPLICIT_SINGLETON_SLUG;
   const ext = contentExtFromPath(model.path);
   const suffix = `.${ext}`;
@@ -44,9 +42,7 @@ export function matchModelPath(
     slug = slug.slice(0, -suffix.length);
   }
   if (!slug) return null;
-  const match: PathMatch = { slug, type: model.type };
-  if (hasLocale) match.locale = m.groups!.locale;
-  return match;
+  return { slug, type: model.type };
 }
 
 export function matchAnyModelPath(
@@ -75,23 +71,17 @@ export function contentExtForType(
 
 export function repoPathFromModel(
   model: Pick<ModelSnapshot, "path">,
-  locale: string | undefined,
   slug: string,
 ): string {
-  let out = model.path;
-  if (locale !== undefined) out = out.replaceAll("{locale}", locale);
-  return out.replaceAll("{slug}", slug);
+  return model.path.replaceAll("{slug}", slug);
 }
 
 // ---------------------------------------------------------------------------
 // S3 layout (git working tree model)
 //
-//   workspaces/{ws}/branches/{branch}/head/{locale}/{type}/{slug}.mdx
-//     mirror of the git branch HEAD — what the public site reads
-//   workspaces/{ws}/branches/{branch}/trees/{userId}/{locale}/{type}/{slug}.mdx
-//     one user's uncommitted file on that branch
-//   workspaces/{ws}/branches/{branch}/meta/shas/{locale}/{type}/{slug}.json
-//     HEAD blob sha per file (conflict base)
+//   workspaces/{ws}/branches/{branch}/head/{type}/{slug}.mdx
+//   workspaces/{ws}/branches/{branch}/trees/{userId}/{type}/{slug}.mdx
+//   workspaces/{ws}/branches/{branch}/meta/shas/{type}/{slug}.json
 // ---------------------------------------------------------------------------
 
 /** Where a doc's bytes came from: the branch HEAD mirror or the caller's working tree. */
@@ -121,55 +111,39 @@ export function s3TreePrefix(
   return `${branchRoot(workspaceId, branch)}/trees/${encodeURIComponent(userId)}/`;
 }
 
-/** URL stand-in when a model path has no `{locale}` — not a language code. */
-export const EMPTY_LOCALE_SEGMENT = "-";
-
-export function encodeDocLocale(locale: string | undefined): string {
-  return locale ? locale : EMPTY_LOCALE_SEGMENT;
-}
-
-export function decodeDocLocale(segment: string): string {
-  return segment === EMPTY_LOCALE_SEGMENT ? "" : segment;
-}
-
-function contentLeaf(type: string, slug: string, ext: string, locale?: string): string {
-  const leaf = `${type}/${slug}.${ext}`;
-  return locale ? `${locale}/${leaf}` : leaf;
+function contentLeaf(type: string, slug: string, ext: string): string {
+  return `${type}/${slug}.${ext}`;
 }
 
 export function s3HeadKey(
   workspaceId: string,
   branch: string,
-  locale: string | undefined,
   type: string,
   slug: string,
   ext = "mdx",
 ): string {
-  return `${s3HeadPrefix(workspaceId, branch)}${contentLeaf(type, slug, ext, locale || undefined)}`;
+  return `${s3HeadPrefix(workspaceId, branch)}${contentLeaf(type, slug, ext)}`;
 }
 
 export function s3TreeKey(
   workspaceId: string,
   branch: string,
   userId: string,
-  locale: string | undefined,
   type: string,
   slug: string,
   ext = "mdx",
 ): string {
-  return `${s3TreePrefix(workspaceId, branch, userId)}${contentLeaf(type, slug, ext, locale || undefined)}`;
+  return `${s3TreePrefix(workspaceId, branch, userId)}${contentLeaf(type, slug, ext)}`;
 }
 
 /** HEAD blob sha for conflict checks. */
 export function s3ShaMetaKey(
   workspaceId: string,
   branch: string,
-  locale: string | undefined,
   type: string,
   slug: string,
 ): string {
-  const leaf = locale ? `${locale}/${type}/${slug}.json` : `${type}/${slug}.json`;
-  return `${branchRoot(workspaceId, branch)}/meta/shas/${leaf}`;
+  return `${branchRoot(workspaceId, branch)}/meta/shas/${type}/${slug}.json`;
 }
 
 export type ParsedContentKey = {
@@ -177,7 +151,6 @@ export type ParsedContentKey = {
   source: ContentSource;
   /** Owner of the working tree; null for head keys. */
   userId: string | null;
-  locale?: string;
   type: string;
   slug: string;
 };
@@ -219,11 +192,8 @@ export function parseS3ContentKey(
   return null;
 }
 
-function parseContentLeaf(leaf: string): { locale?: string; type: string; slug: string } | null {
+function parseContentLeaf(leaf: string): { type: string; slug: string } | null {
   const parts = leaf.split("/");
-  if (parts.length === 3) {
-    return { locale: parts[0], type: parts[1]!, slug: parts[2]! };
-  }
   if (parts.length === 2) {
     return { type: parts[0]!, slug: parts[1]! };
   }

package/src/preview-channel.ts

@@ -9,7 +9,6 @@ import { parsePreviewHotkey, type PreviewHotkeyMessage } from "./preview-hotkeys
 export const PREVIEW_CHANNEL_VERSION = 1 as const;
 
 export type PreviewChannelRef = {
-  locale: string;
   type: string;
   slug: string;
   branch?: string;
@@ -90,7 +89,7 @@ export type PreviewTransport = {
 };
 
 export function samePreviewRef(a: PreviewChannelRef, b: PreviewChannelRef): boolean {
-  if (a.locale !== b.locale || a.type !== b.type || a.slug !== b.slug) return false;
+  if (a.type !== b.type || a.slug !== b.slug) return false;
   if (a.branch && b.branch && a.branch !== b.branch) return false;
   if (a.tree && b.tree && a.tree !== b.tree) return false;
   return true;
@@ -102,11 +101,9 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 
 function readRef(value: unknown): PreviewChannelRef | null {
   if (!isRecord(value)) return null;
-  if (typeof value.locale !== "string" || !value.locale) return null;
   if (typeof value.type !== "string" || !value.type) return null;
   if (typeof value.slug !== "string" || !value.slug) return null;
   const ref: PreviewChannelRef = {
-    locale: value.locale,
     type: value.type,
     slug: value.slug,
   };

package/src/preview.ts

@@ -1,9 +1,7 @@
 // packages/core/src/preview.ts
 import type { BackmatterDoc, BackmatterDocSummary } from "./doc";
-import { encodeDocLocale } from "./path";
 
 export type PreviewDocRef = {
-  locale: string;
   type: string;
   slug: string;
   /** Editor checkout branch. Omit to read the workspace default branch. */
@@ -198,10 +196,9 @@ function previewParams(options: PreviewClientOptions, ref: PreviewDocRef) {
 }
 
 function docPath(options: PreviewClientOptions, ref: PreviewDocRef) {
-  const locale = encodeURIComponent(encodeDocLocale(ref.locale));
   const type = encodeURIComponent(ref.type);
   const slug = encodeURIComponent(ref.slug);
-  return `${baseUrl(options.apiUrl)}/preview/workspaces/${options.workspaceId}/docs/${locale}/${type}/${slug}`;
+  return `${baseUrl(options.apiUrl)}/preview/workspaces/${options.workspaceId}/docs/${type}/${slug}`;
 }
 
 export function previewDocRequestUrl(
@@ -223,7 +220,7 @@ export function previewTreeStreamUrl(
   options: PreviewClientOptions,
   checkout: { branch?: string; tree?: string },
 ): string {
-  return `${baseUrl(options.apiUrl)}/preview/workspaces/${options.workspaceId}/tree/stream?${previewParams(options, { locale: "", type: "", slug: "", ...checkout })}`;
+  return `${baseUrl(options.apiUrl)}/preview/workspaces/${options.workspaceId}/tree/stream?${previewParams(options, { type: "", slug: "", ...checkout })}`;
 }
 
 export async function fetchPreviewDoc(
@@ -244,20 +241,18 @@ export async function fetchPreviewDoc(
  */
 export async function fetchPreviewDocs(
   options: PreviewClientOptions,
-  query: { branch?: string; tree?: string; type?: string; locale?: string },
+  query: { branch?: string; tree?: string; type?: string },
 ): Promise<BackmatterDocSummary[]> {
   const docs: BackmatterDocSummary[] = [];
   let cursor: string | undefined;
   for (let page = 0; page < 100; page++) {
     const params = previewParams(options, {
-      locale: query.locale ?? "",
       type: "",
       slug: "",
       branch: query.branch,
       tree: query.tree,
     });
     if (query.type) params.set("type", query.type);
-    if (query.locale) params.set("locale", query.locale);
     if (cursor) params.set("cursor", cursor);
     const url = `${baseUrl(options.apiUrl)}/preview/workspaces/${options.workspaceId}/docs?${params}`;
     const res = await fetch(url, { cache: "no-store" });

package/src/query.ts

@@ -6,8 +6,8 @@ import { normalizeFrontmatter } from "./zod";
 
 /** Loader the query layer sits on: the FS or API loaders behind createBackmatter. */
 export type DocLoader = {
-  listDocs(filter?: { type?: string; locale?: string }): Promise<BackmatterDocSummary[]>;
-  getDoc(locale: string, type: string, slug: string): Promise<BackmatterDoc | null>;
+  listDocs(filter?: { type?: string }): Promise<BackmatterDocSummary[]>;
+  getDoc(type: string, slug: string): Promise<BackmatterDoc | null>;
 };
 
 export type TypedDoc<M extends ModelDef> = Omit<BackmatterDoc, "type" | "frontmatter"> & {
@@ -19,7 +19,7 @@ type KeysOfKind<M extends ModelDef, K extends FieldKind> = {
   [N in keyof M["fields"]]: M["fields"][N]["kind"] extends K ? N : never;
 }[keyof M["fields"]];
 
-type ScalarKind = "text" | "locale" | "number" | "boolean";
+type ScalarKind = "text" | "number" | "boolean";
 
 /** Equality filters on slug and scalar frontmatter fields. */
 export type Where<M extends ModelDef> = Partial<
@@ -29,7 +29,7 @@ export type Where<M extends ModelDef> = Partial<
   >
 >;
 
-/** Relation fields that may be resolved (depth 1, same locale). */
+/** Relation fields that may be resolved (depth 1). */
 export type Include<M extends ModelDef> = Partial<Record<KeysOfKind<M, "relation">, true>>;
 
 type RelationTarget<
@@ -50,22 +50,13 @@ export type Resolved<
     : never;
 };
 
-type PathHasLocale<M extends ModelDef> = M["path"] extends `${string}{locale}${string}`
-  ? true
-  : false;
-
 type ModelGet<M extends ModelDef> = M["singleton"] extends true
-  ? PathHasLocale<M> extends true
-    ? (locale: string) => Promise<TypedDoc<M> | null>
-    : () => Promise<TypedDoc<M> | null>
-  : PathHasLocale<M> extends true
-    ? (locale: string, slug: string) => Promise<TypedDoc<M> | null>
-    : (slug: string) => Promise<TypedDoc<M> | null>;
+  ? () => Promise<TypedDoc<M> | null>
+  : (slug: string) => Promise<TypedDoc<M> | null>;
 
 export type ModelQuery<M extends ModelDef, Models extends readonly ModelDef[]> = {
   get: ModelGet<M>;
   findMany<I extends Include<M> = {}>(opts?: {
-    locale?: string;
     where?: Where<M>;
     include?: I;
   }): Promise<Array<TypedDoc<M> & Resolved<M, Models, I>>>;
@@ -76,7 +67,6 @@ export type Query<Models extends readonly ModelDef[]> = {
 };
 
 type RawOpts = {
-  locale?: string;
   where?: Record<string, unknown>;
   include?: Record<string, boolean | undefined>;
 };
@@ -87,24 +77,17 @@ export function createQuery<const Models extends readonly ModelDef[]>(
 ): Query<Models> {
   const byType = new Map<string, ModelDef>(models.map((m) => [m.type, m]));
 
-  function identityFor(type: string, a?: string, b?: string): { locale: string; slug: string } {
+  function slugForGet(type: string, arg?: string): string {
     const model = byType.get(type);
-    const localized = model?.path.includes("{locale}") ?? true;
     const singleton = model?.singleton === true;
     if (singleton) {
-      return {
-        locale: localized ? (a ?? "") : "",
-        slug: model?.path.includes("{slug}") ? (localized ? (b ?? IMPLICIT_SINGLETON_SLUG) : (a ?? IMPLICIT_SINGLETON_SLUG)) : IMPLICIT_SINGLETON_SLUG,
-      };
+      return model?.path.includes("{slug}") ? (arg ?? IMPLICIT_SINGLETON_SLUG) : IMPLICIT_SINGLETON_SLUG;
     }
-    return {
-      locale: localized ? (a ?? "") : "",
-      slug: localized ? (b ?? "") : (a ?? ""),
-    };
+    return arg ?? "";
   }
 
-  async function get(type: string, locale: string, slug: string): Promise<BackmatterDoc | null> {
-    const doc = await loader.getDoc(locale, type, slug);
+  async function get(type: string, slug: string): Promise<BackmatterDoc | null> {
+    const doc = await loader.getDoc(type, slug);
     if (!doc) return null;
     return { ...doc, frontmatter: normalizeFrontmatter(doc.frontmatter) };
   }
@@ -123,20 +106,16 @@ export function createQuery<const Models extends readonly ModelDef[]>(
     const whereSlug = opts?.where?.slug;
 
     let docs: BackmatterDoc[];
-    // Truthy gate: the loaders' locale filter is truthiness-based, so a falsy
-    // locale ("") must fall back to the list path like an omitted one.
-    if (typeof whereSlug === "string" && opts?.locale) {
-      // Slug fast-path: identity lookup instead of list + load fan-out.
-      const doc = await get(type, opts.locale, whereSlug);
+    if (typeof whereSlug === "string") {
+      const doc = await get(type, whereSlug);
       docs = doc ? [doc] : [];
     } else {
-      const summaries = await loader.listDocs({ type, locale: opts?.locale });
+      const summaries = await loader.listDocs({ type });
       const fromList = summaries.filter((s) => s.frontmatter != null);
       const missing = summaries.filter((s) => s.frontmatter == null);
-      const loaded = await Promise.all(missing.map((s) => get(type, s.locale, s.slug)));
+      const loaded = await Promise.all(missing.map((s) => get(type, s.slug)));
       docs = [
         ...fromList.map((s) => ({
-          locale: s.locale,
           type: s.type,
           slug: s.slug,
           source: "head" as const,
@@ -152,13 +131,12 @@ export function createQuery<const Models extends readonly ModelDef[]>(
     const include = opts?.include;
     if (!include || !model) return filtered;
 
-    // Memoize relation loads per call: N posts sharing one author load it once.
     const relationCache = new Map<string, Promise<BackmatterDoc | null>>();
-    const getCached = (target: string, locale: string, slug: string) => {
-      const key = `${target}:${locale}:${slug}`;
+    const getCached = (target: string, slug: string) => {
+      const key = `${target}:${slug}`;
       let promise = relationCache.get(key);
       if (!promise) {
-        promise = get(target, locale, slug);
+        promise = get(target, slug);
         relationCache.set(key, promise);
       }
       return promise;
@@ -171,10 +149,10 @@ export function createQuery<const Models extends readonly ModelDef[]>(
           if (!on) continue;
           const field = model.fields[name];
           const target = field?.kind === "relation" ? field.relationTo : undefined;
-          const slug = doc.frontmatter[name];
+          const relatedSlug = doc.frontmatter[name];
           extra[name] =
-            target && typeof slug === "string" && slug.length > 0
-              ? await getCached(target, doc.locale, slug)
+            target && typeof relatedSlug === "string" && relatedSlug.length > 0
+              ? await getCached(target, relatedSlug)
               : null;
         }
         return { ...doc, ...extra };
@@ -185,10 +163,7 @@ export function createQuery<const Models extends readonly ModelDef[]>(
   const query: Record<string, unknown> = {};
   for (const m of models) {
     query[m.type] = {
-      get: (a?: string, b?: string) => {
-        const id = identityFor(m.type, a, b);
-        return get(m.type, id.locale, id.slug);
-      },
+      get: (arg?: string) => get(m.type, slugForGet(m.type, arg)),
       findMany: (opts?: RawOpts) => findMany(m.type, opts),
     };
   }

package/src/routes.ts

@@ -2,7 +2,7 @@
 // Pure URL ↔ document mapping for the host catch-all route. No framework code.
 import type { ModelSnapshot } from "./model";
 
-export const DEFAULT_ROUTE = "/{locale}/{type}/{slug}";
+export const DEFAULT_ROUTE = "/{type}/{slug}";
 
 export type RouteModel = Pick<ModelSnapshot, "type" | "route" | "indexSlug">;
 
@@ -12,35 +12,30 @@ export function isRoutable(model: Pick<RouteModel, "route">): boolean {
 
 export type RouteMatch = {
   type: string;
-  locale: string;
   slug: string;
 };
 
-export type MatchRouteOptions = {
-  /** Locale for routes without a `{locale}` placeholder. */
-  defaultLocale: string;
-  /** When set, `{locale}` only matches one of these values. */
-  locales?: readonly string[];
-};
-
 /** The model's route template with `{type}` already substituted. */
 export function routeTemplate(model: RouteModel): string {
   if (model.route === false) return "";
-  return (model.route ?? DEFAULT_ROUTE).replaceAll("{type}", model.type);
+  const template = model.route ?? DEFAULT_ROUTE;
+  if (template.includes("{locale}")) {
+    throw new Error("model.route must not contain {locale}");
+  }
+  return template.replaceAll("{type}", model.type);
 }
 
-/** Build the public URL path for a document, e.g. "/en/blog/hello". */
-export function routeFor(model: RouteModel, locale: string, slug: string): string {
+/** Build the public URL path for a document, e.g. "/blog/hello". */
+export function routeFor(model: RouteModel, slug: string): string {
   if (model.route === false) return "";
   if (model.indexSlug && slug === model.indexSlug) return "/";
   return routeTemplate(model)
-    .replaceAll("{locale}", encodeURIComponent(locale))
     .replaceAll("{slug}", slug.split("/").map(encodeURIComponent).join("/"));
 }
 
-/** URL segments for Next `generateStaticParams` (["en", "blog", "hello"]). */
-export function routeSegments(model: RouteModel, locale: string, slug: string): string[] {
-  return routeFor(model, locale, slug)
+/** URL segments for Next `generateStaticParams` (["blog", "hello"]). */
+export function routeSegments(model: RouteModel, slug: string): string[] {
+  return routeFor(model, slug)
     .split("/")
     .filter(Boolean)
     .map(decodeURIComponent);
@@ -51,11 +46,13 @@ function escapeRegex(s: string): string {
 }
 
 export function compileRoutePattern(template: string): RegExp {
-  const parts = template.split(/(\{locale\}|\{slug\})/g);
+  if (template.includes("{locale}")) {
+    throw new Error("model.route must not contain {locale}");
+  }
+  const parts = template.split(/(\{slug\})/g);
   let pattern = "^";
   for (const part of parts) {
-    if (part === "{locale}") pattern += "(?<locale>[^/]+)";
-    else if (part === "{slug}") pattern += "(?<slug>[^/]+)";
+    if (part === "{slug}") pattern += "(?<slug>[^/]+)";
     else pattern += escapeRegex(part);
   }
   return new RegExp(`${pattern}/?$`);
@@ -89,13 +86,12 @@ export function normalizePathname(pathname: string): string {
 export function matchRoute(
   models: readonly RouteModel[],
   pathname: string,
-  options: MatchRouteOptions,
 ): RouteMatch | null {
   const target = normalizePathname(pathname);
   if (target === "/") {
     const index = models.find((model) => model.indexSlug && isRoutable(model));
     if (index?.indexSlug) {
-      return { type: index.type, locale: options.defaultLocale, slug: index.indexSlug };
+      return { type: index.type, slug: index.indexSlug };
     }
     return null;
   }
@@ -103,14 +99,7 @@ export function matchRoute(
     const template = routeTemplate(model);
     const m = compileRoutePattern(template).exec(target);
     if (!m?.groups?.slug) continue;
-    let locale = options.defaultLocale;
-    if (template.includes("{locale}")) {
-      const raw = m.groups.locale;
-      if (!raw) continue;
-      locale = decodeURIComponent(raw);
-      if (options.locales && !options.locales.includes(locale)) continue;
-    }
-    return { type: model.type, locale, slug: decodeURIComponent(m.groups.slug) };
+    return { type: model.type, slug: decodeURIComponent(m.groups.slug) };
   }
   return null;
 }

package/src/source.ts

@@ -2,15 +2,15 @@
 // A source resolves the outside record behind an `external` model's route.
 // Host code only (`sources/{type}.ts`); never serialized into the schema.
 
-export type SourceRef = { locale: string; slug: string };
+export type SourceRef = { slug: string };
 
 export type SourceDef<T = unknown> = {
   /** The outside record for a route hit. `null` means the record does not exist (404). */
   load: (ref: SourceRef) => Promise<T | null>;
-  /** Slugs to prerender, per locale. Omit to prerender only slugs that have a CMS file. */
-  list?: (locale: string) => Promise<readonly string[]>;
+  /** Slugs to prerender. Omit to prerender only slugs that have a CMS file. */
+  list?: () => Promise<readonly string[]>;
   /** One representative record for template preview. Omit to preview the template with `data: null`. */
-  sample?: (locale: string) => Promise<T | null>;
+  sample?: () => Promise<T | null>;
   /** Metadata when the document has no `title`. */
   metadata?: (record: T) => { title?: string };
 };

package/src/sync-schema.ts

@@ -38,7 +38,11 @@ export async function syncSchema(options: SyncSchemaOptions): Promise<void> {
     options.objects,
     options.richtext,
   );
-  const body: { payload: ReturnType<typeof serializeSchema>; branch: string; siteUrl?: string } = {
+  const body: {
+    payload: ReturnType<typeof serializeSchema>;
+    branch: string;
+    siteUrl?: string;
+  } = {
     payload,
     branch,
   };