@kdrgny/justjson 1.1.0 → 1.4.0

package/dist/cli.js

@@ -4054,6 +4054,20 @@ var coerce = {
 var NEVER = INVALID;
 
 // ../core/dist/index.js
+var JustJsonError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var NotFoundError = class extends JustJsonError {
+};
+var UnsafeSlugError = class extends JustJsonError {
+};
+var PathEscapeError = class extends JustJsonError {
+};
+var SchemaError = class extends JustJsonError {
+};
 var fieldTypes = [
   "text",
   "richtext",
@@ -4062,23 +4076,34 @@ var fieldTypes = [
   "date",
   "select",
   "relation",
-  "image"
+  "image",
+  "url",
+  "email",
+  "list",
+  "color",
+  "group"
 ];
-var zField = external_exports.object({
-  key: external_exports.string().min(1),
-  label: external_exports.string().optional(),
-  type: external_exports.enum(fieldTypes),
-  required: external_exports.boolean().optional(),
-  options: external_exports.array(external_exports.string()).optional(),
-  to: external_exports.string().optional()
-}).superRefine((field, ctx) => {
-  if (field.type === "select" && (!field.options || field.options.length === 0)) {
-    ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: "select alan\u0131 options gerektirir" });
-  }
-  if (field.type === "relation" && !field.to) {
-    ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: 'relation alan\u0131 "to" gerektirir' });
-  }
-});
+var zField = external_exports.lazy(
+  () => external_exports.object({
+    key: external_exports.string().min(1),
+    label: external_exports.string().optional(),
+    type: external_exports.enum(fieldTypes),
+    required: external_exports.boolean().optional(),
+    options: external_exports.array(external_exports.string()).optional(),
+    to: external_exports.string().optional(),
+    fields: external_exports.array(zField).optional()
+  }).superRefine((field, ctx) => {
+    if (field.type === "select" && (!field.options || field.options.length === 0)) {
+      ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: "a select field requires options" });
+    }
+    if (field.type === "relation" && !field.to) {
+      ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: 'a relation field requires "to"' });
+    }
+    if (field.type === "group" && (!field.fields || field.fields.length === 0)) {
+      ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: "a group field requires fields" });
+    }
+  })
+);
 var zCollection = external_exports.object({
   name: external_exports.string().min(1),
   label: external_exports.string().optional(),
@@ -4102,30 +4127,38 @@ var zSchema = external_exports.object({
   const containers = [...schema.collections, ...schema.singletons];
   for (const c of containers) {
     if (names.has(c.name)) {
-      ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: `tekrar eden ad: ${c.name}` });
+      ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: `duplicate name: ${c.name}` });
     }
     names.add(c.name);
     if (c.path.includes("..") || c.path.startsWith("/") || c.path.includes("\\")) {
-      ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: `g\xFCvensiz path: ${c.path}` });
+      ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: `unsafe path: ${c.path}` });
     }
     if (paths.has(c.path)) {
-      ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: `tekrar eden path: ${c.path}` });
+      ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: `duplicate path: ${c.path}` });
     }
     paths.add(c.path);
     const keys = /* @__PURE__ */ new Set();
     for (const f of c.fields) {
       if (keys.has(f.key)) {
-        ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: `tekrar eden field key: ${f.key}` });
+        ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: `duplicate field key: ${f.key}` });
       }
       keys.add(f.key);
       if (f.type === "relation" && f.to && !collectionNames.has(f.to)) {
-        ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: `relation hedefi yok: ${f.to}` });
+        ctx.addIssue({
+          code: external_exports.ZodIssueCode.custom,
+          message: `relation target does not exist: ${f.to}`
+        });
       }
     }
   }
 });
 function parseSchema(input) {
-  return zSchema.parse(input);
+  const result = zSchema.safeParse(input);
+  if (result.success) return result.data;
+  const lines = result.error.issues.map(
+    (i) => i.path.length ? `${i.path.join(".")}: ${i.message}` : i.message
+  );
+  throw new SchemaError(lines.join("\n"));
 }
 function serializeSchema(schema) {
   return `${JSON.stringify(schema, null, 2)}
@@ -4149,7 +4182,7 @@ var TR = {
 function slugify(input) {
   const mapped = input.replace(/[çğıöşüÇĞİÖŞÜI]/g, (c) => TR[c] ?? c);
   const slug = mapped.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  return slug || "icerik";
+  return slug || "content";
 }
 var TITLE_KEYS = ["title", "name", "baslik", "ba\u015Fl\u0131k", "ad", "label", "heading", "isim"];
 function entryTitle(fields, data) {
@@ -4171,7 +4204,7 @@ function schemaPath(contentDir) {
 }
 function assertSafeSlug(slug) {
   if (slug.length === 0 || slug.includes("/") || slug.includes("\\") || slug.includes("..")) {
-    throw new Error(`G\xFCvensiz slug: ${slug}`);
+    throw new UnsafeSlugError(`Unsafe slug: ${slug}`);
   }
 }
 async function loadSchema(adapter, contentDir = "content") {
@@ -4193,12 +4226,12 @@ var ContentStore = class {
   contentDir;
   collection(name) {
     const col = this.schema.collections.find((c) => c.name === name);
-    if (!col) throw new Error(`Bilinmeyen koleksiyon: ${name}`);
+    if (!col) throw new NotFoundError(`Bilinmeyen koleksiyon: ${name}`);
     return col;
   }
   singleton(name) {
     const s = this.schema.singletons.find((x) => x.name === name);
-    if (!s) throw new Error(`Bilinmeyen singleton: ${name}`);
+    if (!s) throw new NotFoundError(`Bilinmeyen singleton: ${name}`);
     return s;
   }
   entryPath(col, slug) {
@@ -4251,6 +4284,206 @@ var ContentStore = class {
 `);
   }
 };
+function isEmpty(value) {
+  return value === void 0 || value === null || value === "";
+}
+var URL_RE = /^[a-z][a-z0-9+.-]*:\/\/.+/i;
+var EMAIL_RE = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;
+var COLOR_RE = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i;
+function typeError(field, value) {
+  switch (field.type) {
+    case "text":
+    case "richtext":
+    case "date":
+    case "image":
+      return typeof value === "string" ? null : "expected text";
+    case "url":
+      if (typeof value !== "string") return "expected text";
+      return URL_RE.test(value) ? null : "expected a valid URL";
+    case "email":
+      if (typeof value !== "string") return "expected text";
+      return EMAIL_RE.test(value) ? null : "expected a valid email address";
+    case "color":
+      if (typeof value !== "string") return "expected text";
+      return COLOR_RE.test(value) ? null : "expected a hex color (e.g. #ff0000)";
+    case "list":
+      if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) {
+        return "expected a list of text";
+      }
+      return null;
+    case "relation":
+      if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) {
+        return "expected a list of slugs";
+      }
+      return null;
+    case "group":
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return "expected an object";
+      }
+      return null;
+    case "number":
+      return typeof value === "number" ? null : "expected a number";
+    case "boolean":
+      return typeof value === "boolean" ? null : "expected true or false";
+    case "select":
+      if (typeof value !== "string") return "expected text";
+      return field.options?.includes(value) ? null : "not one of the options";
+  }
+}
+function validateEntry(fields, data) {
+  const issues = [];
+  const known = new Set(fields.map((f) => f.key));
+  for (const field of fields) {
+    const value = data[field.key];
+    if (isEmpty(value)) {
+      if (field.required) {
+        issues.push({
+          key: field.key,
+          level: "warning",
+          kind: "required",
+          message: "required field is empty"
+        });
+      }
+      continue;
+    }
+    const err = typeError(field, value);
+    if (err) issues.push({ key: field.key, level: "error", kind: "type", message: err });
+  }
+  for (const key of Object.keys(data)) {
+    if (key.startsWith("_")) continue;
+    if (!known.has(key)) {
+      issues.push({
+        key,
+        level: "warning",
+        kind: "unknown-key",
+        message: "key is not in the schema"
+      });
+    }
+  }
+  return { ok: issues.every((i) => i.level !== "error"), issues };
+}
+function basename(path) {
+  return path.split(/[/\\]/).pop() ?? path;
+}
+function imageFields(fields) {
+  return fields.filter((f) => f.type === "image");
+}
+function relationFields(fields) {
+  return fields.filter((f) => f.type === "relation");
+}
+function validateProject(schema, content) {
+  const issues = [];
+  const mediaNames = content.media ? new Set(content.media.map(basename)) : null;
+  const schemaCollectionNames = new Set(schema.collections.map((c) => c.name));
+  for (const name of Object.keys(content.collections)) {
+    if (!schemaCollectionNames.has(name)) {
+      issues.push({
+        level: "warning",
+        kind: "schema-content-mismatch",
+        collection: name,
+        message: `Collection folder '${name}' is not in the schema`
+      });
+    }
+  }
+  const slugsByCollection = {};
+  for (const [name, entries] of Object.entries(content.collections)) {
+    slugsByCollection[name] = new Set(entries.map((e) => e.slug));
+  }
+  for (const col of schema.collections) {
+    const entries = content.collections[col.name] ?? [];
+    const seen = /* @__PURE__ */ new Set();
+    const reported = /* @__PURE__ */ new Set();
+    for (const { slug } of entries) {
+      if (seen.has(slug) && !reported.has(slug)) {
+        reported.add(slug);
+        issues.push({
+          level: "error",
+          kind: "duplicate-slug",
+          collection: col.name,
+          slug,
+          message: `Duplicate slug in '${col.name}': ${slug}`
+        });
+      }
+      seen.add(slug);
+    }
+    const rels = relationFields(col.fields);
+    const imgs = imageFields(col.fields);
+    for (const { slug, data } of entries) {
+      for (const issue of validateEntry(col.fields, data).issues) {
+        issues.push({
+          level: issue.level,
+          kind: issue.kind,
+          collection: col.name,
+          slug,
+          field: issue.key,
+          message: issue.message
+        });
+      }
+      for (const field of rels) {
+        const value = data[field.key];
+        if (!Array.isArray(value)) continue;
+        const target = field.to ? slugsByCollection[field.to] : void 0;
+        for (const ref of value) {
+          if (typeof ref !== "string") continue;
+          if (!target || !target.has(ref)) {
+            issues.push({
+              level: "error",
+              kind: "broken-relation",
+              collection: col.name,
+              slug,
+              field: field.key,
+              message: field.to ? `Broken relation: '${ref}' does not exist in '${field.to}'` : `Relation field '${field.key}' has no target collection`
+            });
+          }
+        }
+      }
+      if (mediaNames) {
+        for (const field of imgs) {
+          const value = data[field.key];
+          if (typeof value !== "string" || value === "") continue;
+          if (!mediaNames.has(basename(value))) {
+            issues.push({
+              level: "error",
+              kind: "missing-media",
+              collection: col.name,
+              slug,
+              field: field.key,
+              message: `Missing media: ${value}`
+            });
+          }
+        }
+      }
+    }
+  }
+  for (const s of schema.singletons) {
+    const data = content.singletons[s.name] ?? {};
+    for (const issue of validateEntry(s.fields, data).issues) {
+      issues.push({
+        level: issue.level,
+        kind: issue.kind,
+        singleton: s.name,
+        field: issue.key,
+        message: issue.message
+      });
+    }
+    if (mediaNames) {
+      for (const field of imageFields(s.fields)) {
+        const value = data[field.key];
+        if (typeof value !== "string" || value === "") continue;
+        if (!mediaNames.has(basename(value))) {
+          issues.push({
+            level: "error",
+            kind: "missing-media",
+            singleton: s.name,
+            field: field.key,
+            message: `Missing media: ${value}`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
 function pascalCase(name) {
   return name.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
@@ -4263,7 +4496,14 @@ function fieldTsType(field) {
     case "select":
       return (field.options ?? []).map((o) => `'${o}'`).join(" | ") || "string";
     case "relation":
+    case "list":
       return "string[]";
+    case "group": {
+      const subs = field.fields ?? [];
+      if (subs.length === 0) return "Record<string, unknown>";
+      const inner = subs.map((f) => `${f.key}${f.required ? "" : "?"}: ${fieldTsType(f)}`).join("; ");
+      return `{ ${inner} }`;
+    }
     default:
       return "string";
   }
@@ -4278,7 +4518,7 @@ ${lines.join("\n")}
 }`;
 }
 function generateTypes(schema) {
-  const blocks = ["// JustJSON taraf\u0131ndan \xFCretildi \u2014 elle d\xFCzenlemeyin."];
+  const blocks = ["// Generated by JustJSON \u2014 do not edit by hand."];
   for (const col of schema.collections) {
     const name = pascalCase(col.name);
     blocks.push(emitInterface(name, col.fields));
@@ -4290,6 +4530,71 @@ function generateTypes(schema) {
   return `${blocks.join("\n\n")}
 `;
 }
+function pascalCase2(name) {
+  return name.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+var IMPORTS = `import { readFile, readdir } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'`;
+var READERS = `export type WithSlug<T> = T & { slug: string }
+
+export interface LoadOptions {
+  /** true ise _status: 'draft' olan kay\u0131tlar da dahil edilir (varsay\u0131lan: yaln\u0131zca yay\u0131nlananlar). */
+  drafts?: boolean
+}
+
+async function readCollection<T>(dir: string, opts?: LoadOptions): Promise<WithSlug<T>[]> {
+  let files: string[]
+  try {
+    files = (await readdir(join(contentDir, dir))).filter((f) => f.endsWith('.json'))
+  } catch {
+    return []
+  }
+  const out: WithSlug<T>[] = []
+  for (const file of files.sort()) {
+    const raw = await readFile(join(contentDir, dir, file), 'utf8')
+    const data = JSON.parse(raw) as T & { _status?: string }
+    if (!opts?.drafts && data._status === 'draft') continue
+    out.push({ ...data, slug: file.slice(0, -'.json'.length) })
+  }
+  return out
+}
+
+async function readSingleton<T>(file: string): Promise<T | null> {
+  try {
+    return JSON.parse(await readFile(join(contentDir, file), 'utf8')) as T
+  } catch {
+    return null
+  }
+}`;
+function generateLoader(schema, contentDir) {
+  const typeNames = [
+    ...schema.collections.map((c) => pascalCase2(c.name)),
+    ...schema.singletons.map((s) => pascalCase2(s.name))
+  ];
+  const header = [
+    "// Generated by JustJSON \u2014 do not edit by hand.",
+    IMPORTS,
+    `import type { ${typeNames.join(", ")} } from './types'`
+  ].join("\n");
+  const q = (s) => `'${s.replace(/'/g, "\\'")}'`;
+  const contentDirLine = `const contentDir = join(dirname(fileURLToPath(import.meta.url)), ${q(contentDir)})`;
+  const loaders = [];
+  for (const col of schema.collections) {
+    const name = pascalCase2(col.name);
+    loaders.push(
+      `export const load${name} = (opts?: LoadOptions): Promise<WithSlug<${name}>[]> => readCollection<${name}>(${q(col.path)}, opts)`
+    );
+  }
+  for (const s of schema.singletons) {
+    const name = pascalCase2(s.name);
+    loaders.push(
+      `export const load${name} = (): Promise<${name} | null> => readSingleton<${name}>(${q(s.path)})`
+    );
+  }
+  return `${[header, contentDirLine, READERS, loaders.join("\n")].join("\n\n")}
+`;
+}
 function json(data) {
   return `${JSON.stringify(data, null, 2)}
 `;
@@ -4342,7 +4647,7 @@ function fieldsFromRows(rows) {
   return order.map((key) => ({ key, label: key, type: types.get(key) }));
 }
 function inferProject(data) {
-  if (!isPlainObject(data)) throw new Error("\u0130\xE7e aktar\u0131lan JSON bir nesne olmal\u0131.");
+  if (!isPlainObject(data)) throw new Error("The imported JSON must be an object.");
   const collections = [];
   const singletons = [];
   const entries = {};
@@ -4351,7 +4656,7 @@ function inferProject(data) {
   const generalData = {};
   const usedNames = /* @__PURE__ */ new Set();
   const uniqueName = (base) => {
-    let name = base || "alan";
+    let name = base || "field";
     let n = 2;
     while (usedNames.has(name)) name = `${base}-${n++}`;
     usedNames.add(name);
@@ -4400,8 +4705,8 @@ function inferProject(data) {
     }
   }
   if (generalFields.length > 0) {
-    const name = uniqueName("genel");
-    singletons.push({ name, label: "Genel", path: `${name}.json`, fields: generalFields });
+    const name = uniqueName("general");
+    singletons.push({ name, label: "General", path: `${name}.json`, fields: generalFields });
     singletonData[name] = generalData;
   }
   return { schema: { version: 1, collections, singletons }, entries, singletons: singletonData };
@@ -4422,7 +4727,7 @@ var FsAdapter = class {
     const rootAbs = resolve(this.root);
     const full = resolve(rootAbs, path);
     if (full !== rootAbs && !full.startsWith(rootAbs + sep)) {
-      throw new Error(`Yol k\xF6k d\u0131\u015F\u0131na \xE7\u0131k\u0131yor: ${path}`);
+      throw new PathEscapeError(`Path escapes the project root: ${path}`);
     }
     return full;
   }
@@ -4481,7 +4786,7 @@ async function resolveContentDir(root2) {
 // src/commands/export.ts
 async function collectExportZip(adapter, contentDir) {
   const schema = await loadSchema(adapter, contentDir);
-  if (!schema) throw new Error("\u015Eema bulunamad\u0131. \xD6nce `justjson init` \xE7al\u0131\u015Ft\u0131r\u0131n.");
+  if (!schema) throw new Error("No schema found. Run `justjson init` first.");
   const store = new ContentStore(adapter, schema, contentDir);
   const entries = {};
   for (const col of schema.collections) {
@@ -4518,58 +4823,187 @@ async function exportZip(root2, outFile = "justjson-export.zip") {
 // src/templates/blog.json
 var blog_default = {
   title: "Blog",
-  description: "Rich-text i\xE7erikli yaz\u0131lar ve site ad\u0131 i\xE7in bir Ayarlar.",
+  description: "Posts with rich-text content, plus a Settings singleton for the site name.",
   schema: {
     version: 1,
     collections: [
       {
         name: "posts",
-        label: "Yaz\u0131lar",
+        label: "Posts",
         path: "posts",
         fields: [
-          { key: "title", label: "Ba\u015Fl\u0131k", type: "text", required: true },
-          { key: "slug", label: "Slug", type: "text", required: true },
-          { key: "date", label: "Tarih", type: "date" },
-          { key: "body", label: "\u0130\xE7erik", type: "richtext" }
+          {
+            key: "title",
+            label: "Title",
+            type: "text",
+            required: true
+          },
+          {
+            key: "slug",
+            label: "Slug",
+            type: "text",
+            required: true
+          },
+          {
+            key: "date",
+            label: "Date",
+            type: "date"
+          },
+          {
+            key: "body",
+            label: "Body",
+            type: "richtext"
+          }
         ]
       }
     ],
     singletons: [
       {
         name: "settings",
-        label: "Ayarlar",
+        label: "Settings",
         path: "settings.json",
-        fields: [{ key: "title", label: "Site ad\u0131", type: "text" }]
+        fields: [
+          {
+            key: "title",
+            label: "Site name",
+            type: "text"
+          }
+        ]
+      }
+    ]
+  },
+  samples: {
+    posts: [
+      {
+        title: "First post",
+        slug: "first-post",
+        body: "Hello."
+      }
+    ]
+  }
+};
+
+// src/templates/catalog.json
+var catalog_default = {
+  title: "Product catalog",
+  description: "Products with price, category and an image, plus Store settings.",
+  schema: {
+    version: 1,
+    collections: [
+      {
+        name: "products",
+        label: "Products",
+        path: "products",
+        fields: [
+          {
+            key: "title",
+            label: "Title",
+            type: "text",
+            required: true
+          },
+          {
+            key: "slug",
+            label: "Slug",
+            type: "text",
+            required: true
+          },
+          {
+            key: "price",
+            label: "Price",
+            type: "number"
+          },
+          {
+            key: "category",
+            label: "Category",
+            type: "select",
+            options: ["Home", "Clothing", "Accessories"]
+          },
+          {
+            key: "cover",
+            label: "Image",
+            type: "image"
+          },
+          {
+            key: "description",
+            label: "Description",
+            type: "richtext"
+          }
+        ]
+      }
+    ],
+    singletons: [
+      {
+        name: "store",
+        label: "Store",
+        path: "store.json",
+        fields: [
+          {
+            key: "title",
+            label: "Store name",
+            type: "text"
+          },
+          {
+            key: "tagline",
+            label: "Tagline",
+            type: "text"
+          }
+        ]
       }
     ]
   },
   samples: {
-    posts: [{ title: "\u0130lk yaz\u0131", slug: "ilk-yazi", body: "Merhaba." }]
+    products: [
+      {
+        title: "Ceramic mug",
+        slug: "ceramic-mug",
+        price: 18,
+        category: "Home",
+        description: "Hand-made ceramic mug."
+      }
+    ]
   }
 };
 
 // src/templates/changelog.json
 var changelog_default = {
   title: "Changelog",
-  description: "S\xFCr\xFCm notlar\u0131: versiyon, tarih, t\xFCr ve rich-text a\xE7\u0131klama.",
+  description: "Release notes: version, date, type and a rich-text body.",
   schema: {
     version: 1,
     collections: [
       {
         name: "releases",
-        label: "S\xFCr\xFCmler",
+        label: "Releases",
         path: "releases",
         fields: [
-          { key: "version", label: "Versiyon", type: "text", required: true },
-          { key: "slug", label: "Slug", type: "text", required: true },
-          { key: "date", label: "Tarih", type: "date" },
+          {
+            key: "version",
+            label: "Version",
+            type: "text",
+            required: true
+          },
+          {
+            key: "slug",
+            label: "Slug",
+            type: "text",
+            required: true
+          },
+          {
+            key: "date",
+            label: "Date",
+            type: "date"
+          },
           {
             key: "type",
-            label: "T\xFCr",
+            label: "Type",
             type: "select",
-            options: ["Eklendi", "De\u011Fi\u015Fti", "D\xFCzeltildi"]
+            options: ["Added", "Changed", "Fixed"]
           },
-          { key: "body", label: "Notlar", type: "richtext" }
+          {
+            key: "body",
+            label: "Notes",
+            type: "richtext"
+          }
         ]
       }
     ],
@@ -4580,8 +5014,8 @@ var changelog_default = {
       {
         version: "1.0.0",
         slug: "1-0-0",
-        type: "Eklendi",
-        body: "\u0130lk s\xFCr\xFCm."
+        type: "Added",
+        body: "First release."
       }
     ]
   }
@@ -4590,113 +5024,302 @@ var changelog_default = {
 // src/templates/cv.json
 var cv_default = {
   title: "CV",
-  description: "Deneyim koleksiyonu ve ki\u015Fisel bilgiler i\xE7in bir Profil.",
+  description: "An Experience collection and a Profile singleton for your personal details.",
   schema: {
     version: 1,
     collections: [
       {
         name: "experience",
-        label: "Deneyim",
+        label: "Experience",
         path: "experience",
         fields: [
-          { key: "role", label: "Pozisyon", type: "text", required: true },
-          { key: "company", label: "\u015Eirket", type: "text", required: true },
-          { key: "summary", label: "\xD6zet", type: "richtext" }
+          {
+            key: "role",
+            label: "Role",
+            type: "text",
+            required: true
+          },
+          {
+            key: "company",
+            label: "Company",
+            type: "text",
+            required: true
+          },
+          {
+            key: "summary",
+            label: "Summary",
+            type: "richtext"
+          }
         ]
       }
     ],
     singletons: [
       {
         name: "profile",
-        label: "Profil",
+        label: "Profile",
         path: "profile.json",
         fields: [
-          { key: "name", label: "Ad", type: "text", required: true },
-          { key: "headline", label: "Ba\u015Fl\u0131k", type: "text" }
+          {
+            key: "name",
+            label: "Name",
+            type: "text",
+            required: true
+          },
+          {
+            key: "headline",
+            label: "Headline",
+            type: "text"
+          }
         ]
       }
     ]
   },
   samples: {
-    experience: [{ role: "Yaz\u0131l\u0131mc\u0131", company: "\xD6rnek A.\u015E.", summary: "..." }]
+    experience: [
+      {
+        role: "Developer",
+        company: "Acme Inc.",
+        summary: "..."
+      }
+    ]
   }
 };
 
 // src/templates/docs.json
 var docs_default = {
-  title: "Dok\xFCmantasyon",
-  description: "S\u0131ralanabilir sayfalar ve rich-text i\xE7erik; site ba\u015Fl\u0131\u011F\u0131 i\xE7in bir Ayarlar.",
+  title: "Documentation",
+  description: "Orderable pages with rich-text content, plus a Settings singleton for the site title.",
   schema: {
     version: 1,
     collections: [
       {
         name: "pages",
-        label: "Sayfalar",
+        label: "Pages",
         path: "pages",
         fields: [
-          { key: "title", label: "Ba\u015Fl\u0131k", type: "text", required: true },
-          { key: "slug", label: "Slug", type: "text", required: true },
-          { key: "order", label: "S\u0131ra", type: "number" },
-          { key: "body", label: "\u0130\xE7erik", type: "richtext" }
+          {
+            key: "title",
+            label: "Title",
+            type: "text",
+            required: true
+          },
+          {
+            key: "slug",
+            label: "Slug",
+            type: "text",
+            required: true
+          },
+          {
+            key: "order",
+            label: "Order",
+            type: "number"
+          },
+          {
+            key: "body",
+            label: "Body",
+            type: "richtext"
+          }
         ]
       }
     ],
     singletons: [
       {
         name: "settings",
-        label: "Ayarlar",
+        label: "Settings",
         path: "settings.json",
         fields: [
-          { key: "title", label: "Site ad\u0131", type: "text" },
-          { key: "tagline", label: "Slogan", type: "text" }
+          {
+            key: "title",
+            label: "Site name",
+            type: "text"
+          },
+          {
+            key: "tagline",
+            label: "Tagline",
+            type: "text"
+          }
         ]
       }
     ]
   },
   samples: {
     pages: [
-      { title: "Ba\u015Flarken", slug: "baslarken", order: 1, body: "Kuruluma ho\u015F geldin." }
+      {
+        title: "Getting started",
+        slug: "getting-started",
+        order: 1,
+        body: "Welcome aboard."
+      }
+    ]
+  }
+};
+
+// src/templates/event.json
+var event_default = {
+  title: "Event schedule",
+  description: "An event agenda of sessions with date, time and speaker.",
+  schema: {
+    version: 1,
+    collections: [
+      {
+        name: "sessions",
+        label: "Sessions",
+        path: "sessions",
+        fields: [
+          {
+            key: "title",
+            label: "Title",
+            type: "text",
+            required: true
+          },
+          {
+            key: "slug",
+            label: "Slug",
+            type: "text",
+            required: true
+          },
+          {
+            key: "date",
+            label: "Date",
+            type: "date"
+          },
+          {
+            key: "time",
+            label: "Time",
+            type: "text"
+          },
+          {
+            key: "speaker",
+            label: "Speaker",
+            type: "text"
+          },
+          {
+            key: "room",
+            label: "Room",
+            type: "text"
+          },
+          {
+            key: "description",
+            label: "Description",
+            type: "richtext"
+          }
+        ]
+      }
+    ],
+    singletons: [
+      {
+        name: "event",
+        label: "Event",
+        path: "event.json",
+        fields: [
+          {
+            key: "title",
+            label: "Event name",
+            type: "text"
+          },
+          {
+            key: "tagline",
+            label: "Tagline",
+            type: "text"
+          }
+        ]
+      }
+    ]
+  },
+  samples: {
+    sessions: [
+      {
+        title: "Opening keynote",
+        slug: "opening-keynote",
+        time: "09:00",
+        speaker: "Ada Lovelace",
+        room: "Main hall",
+        description: "Welcome to the event."
+      }
     ]
   }
 };
 
 // src/templates/portfolio.json
 var portfolio_default = {
-  title: "Portfolyo",
-  description: "Kapak g\xF6rseli, etiket ve rich-text i\xE7erikli projeler; bir de Hakk\u0131nda sayfas\u0131.",
+  title: "Portfolio",
+  description: "Projects with a cover image, tag and rich-text body, plus an About page.",
   schema: {
     version: 1,
     collections: [
       {
         name: "projects",
-        label: "Projeler",
+        label: "Projects",
         path: "projects",
         fields: [
-          { key: "title", label: "Ba\u015Fl\u0131k", type: "text", required: true },
-          { key: "slug", label: "Slug", type: "text", required: true },
-          { key: "summary", label: "\xD6zet", type: "text" },
-          { key: "cover", label: "Kapak", type: "image" },
-          { key: "url", label: "Ba\u011Flant\u0131", type: "text" },
+          {
+            key: "title",
+            label: "Title",
+            type: "text",
+            required: true
+          },
+          {
+            key: "slug",
+            label: "Slug",
+            type: "text",
+            required: true
+          },
+          {
+            key: "summary",
+            label: "Summary",
+            type: "text"
+          },
+          {
+            key: "cover",
+            label: "Cover",
+            type: "image"
+          },
+          {
+            key: "url",
+            label: "Link",
+            type: "url"
+          },
           {
             key: "kind",
-            label: "T\xFCr",
+            label: "Kind",
             type: "select",
-            options: ["Web", "Mobil", "Tasar\u0131m"]
+            options: ["Web", "Mobile", "Design"]
+          },
+          {
+            key: "body",
+            label: "Body",
+            type: "richtext"
           },
-          { key: "body", label: "\u0130\xE7erik", type: "richtext" },
-          { key: "date", label: "Tarih", type: "date" }
+          {
+            key: "date",
+            label: "Date",
+            type: "date"
+          }
         ]
       }
     ],
     singletons: [
       {
         name: "about",
-        label: "Hakk\u0131nda",
+        label: "About",
         path: "about.json",
         fields: [
-          { key: "name", label: "Ad", type: "text", required: true },
-          { key: "avatar", label: "Avatar", type: "image" },
-          { key: "bio", label: "Biyografi", type: "richtext" }
+          {
+            key: "name",
+            label: "Name",
+            type: "text",
+            required: true
+          },
+          {
+            key: "avatar",
+            label: "Avatar",
+            type: "image"
+          },
+          {
+            key: "bio",
+            label: "Bio",
+            type: "richtext"
+          }
         ]
       }
     ]
@@ -4704,11 +5327,92 @@ var portfolio_default = {
   samples: {
     projects: [
       {
-        title: "\xD6rnek Proje",
-        slug: "ornek-proje",
-        summary: "K\u0131sa bir a\xE7\u0131klama.",
+        title: "Sample project",
+        slug: "sample-project",
+        summary: "A short description.",
         kind: "Web",
-        body: "Proje detaylar\u0131 burada."
+        body: "Project details go here."
+      }
+    ]
+  }
+};
+
+// src/templates/recipe.json
+var recipe_default = {
+  title: "Recipe box",
+  description: "Recipes with ingredients, steps and a cover image, plus Kitchen settings.",
+  schema: {
+    version: 1,
+    collections: [
+      {
+        name: "recipes",
+        label: "Recipes",
+        path: "recipes",
+        fields: [
+          {
+            key: "title",
+            label: "Title",
+            type: "text",
+            required: true
+          },
+          {
+            key: "slug",
+            label: "Slug",
+            type: "text",
+            required: true
+          },
+          {
+            key: "time",
+            label: "Time",
+            type: "text"
+          },
+          {
+            key: "servings",
+            label: "Servings",
+            type: "number"
+          },
+          {
+            key: "cover",
+            label: "Cover",
+            type: "image"
+          },
+          {
+            key: "ingredients",
+            label: "Ingredients",
+            type: "richtext"
+          },
+          {
+            key: "steps",
+            label: "Steps",
+            type: "richtext"
+          }
+        ]
+      }
+    ],
+    singletons: [
+      {
+        name: "kitchen",
+        label: "Kitchen",
+        path: "kitchen.json",
+        fields: [
+          {
+            key: "title",
+            label: "Site name",
+            type: "text"
+          }
+        ]
+      }
+    ]
+  },
+  samples: {
+    recipes: [
+      {
+        title: "Weeknight pasta",
+        slug: "weeknight-pasta",
+        time: "20 min",
+        servings: 2,
+        ingredients: "- 200g pasta\n- 2 cloves garlic\n- Olive oil",
+        steps: "Boil the pasta. Fry the garlic in olive oil. Toss together."
       }
     ]
   }
@@ -4720,7 +5424,10 @@ var templates = {
   cv: cv_default,
   portfolio: portfolio_default,
   docs: docs_default,
-  changelog: changelog_default
+  changelog: changelog_default,
+  recipe: recipe_default,
+  event: event_default,
+  catalog: catalog_default
 };
 function listTemplates() {
   return Object.keys(templates);
@@ -4749,7 +5456,7 @@ async function applyTemplate(adapter, contentDir, template) {
   const store = new ContentStore(adapter, schema, contentDir);
   for (const [collection, rows] of Object.entries(template.samples)) {
     for (const row of rows) {
-      const slug = slugify(typeof row.slug === "string" ? row.slug : String(row.title ?? "icerik"));
+      const slug = slugify(typeof row.slug === "string" ? row.slug : String(row.title ?? "content"));
       await store.writeEntry(collection, slug, row);
     }
   }
@@ -4761,30 +5468,173 @@ async function initProject(root2, templateName) {
   const adapter = new FsAdapter(root2);
   const contentDir = await resolveContentDir(root2);
   if (await loadSchema(adapter, contentDir)) {
-    throw new Error("Bu klas\xF6rde zaten bir \u015Fema var (content/_schema.json).");
+    throw new Error("This folder already has a schema (content/_schema.json).");
   }
   await applyTemplate(adapter, contentDir, template);
 }
 
 // src/commands/types.ts
 import { join as join2 } from "path";
-async function generateTypesFile(root2, outPath = "types.ts") {
+async function generateTypesFile(root2, outPath = "types.ts", loaderPath = "content.ts") {
   const adapter = new FsAdapter(root2);
   const contentDir = await resolveContentDir(root2);
   const schema = await loadSchema(adapter, contentDir);
-  if (!schema) throw new Error("\u015Eema bulunamad\u0131. \xD6nce `justjson init` \xE7al\u0131\u015Ft\u0131r\u0131n.");
+  if (!schema) throw new Error("No schema found. Run `justjson init` first.");
   await adapter.write(outPath, generateTypes(schema));
+  await adapter.write(loaderPath, generateLoader(schema, contentDir));
   return join2(root2, outPath);
 }
 
+// src/commands/validate.ts
+import { readdir as readdir2 } from "fs/promises";
+import { join as join3 } from "path";
+async function listDir(path) {
+  try {
+    const entries = await readdir2(path, { withFileTypes: true });
+    return entries.map((e) => ({ name: e.name, isDir: e.isDirectory() }));
+  } catch {
+    return [];
+  }
+}
+async function loadProjectContent(root2) {
+  const adapter = new FsAdapter(root2);
+  const contentDir = await resolveContentDir(root2);
+  const schema = await loadSchema(adapter, contentDir);
+  if (!schema) return null;
+  const store = new ContentStore(adapter, schema, contentDir);
+  const collections = {};
+  for (const col of schema.collections) {
+    const slugs = await store.listEntries(col.name);
+    const entries = [];
+    for (const slug of slugs) {
+      entries.push({ slug, data: await store.readEntry(col.name, slug) ?? {} });
+    }
+    collections[col.name] = entries;
+  }
+  const known = new Set(schema.collections.map((c) => c.name));
+  for (const { name, isDir } of await listDir(join3(root2, contentDir))) {
+    if (!isDir || name === "media" || known.has(name) || collections[name]) continue;
+    const files = await listDir(join3(root2, contentDir, name));
+    collections[name] = files.filter((f) => !f.isDir && f.name.endsWith(".json")).map((f) => ({ slug: f.name.slice(0, -".json".length), data: {} }));
+  }
+  const singletons = {};
+  for (const s of schema.singletons) {
+    singletons[s.name] = await store.readSingleton(s.name);
+  }
+  const media = (await listDir(join3(root2, contentDir, "media"))).filter((f) => !f.isDir).map((f) => `${contentDir}/media/${f.name}`);
+  return { schema, content: { collections, singletons, media } };
+}
+async function validateProjectAt(root2) {
+  const loaded = await loadProjectContent(root2);
+  if (!loaded) return null;
+  return validateProject(loaded.schema, loaded.content);
+}
+function summarize(issues) {
+  let errors = 0;
+  let warnings = 0;
+  for (const i of issues) {
+    if (i.level === "error") errors++;
+    else warnings++;
+  }
+  return { errors, warnings };
+}
+function shouldFail(issues, strict) {
+  const { errors, warnings } = summarize(issues);
+  return errors > 0 || strict && warnings > 0;
+}
+function location(issue) {
+  const parts = [];
+  if (issue.collection) parts.push(issue.collection);
+  if (issue.singleton) parts.push(issue.singleton);
+  if (issue.slug) parts.push(issue.slug);
+  if (issue.field) parts.push(issue.field);
+  return parts.join(":") || "(project)";
+}
+function formatText(issues) {
+  if (issues.length === 0) return "\u2713 No issues \u2014 content matches the schema.";
+  const lines = issues.map((i) => {
+    const tag = i.level === "error" ? "ERROR" : "WARN ";
+    return `  ${tag}  ${location(i)}  ${i.message}`;
+  });
+  const { errors, warnings } = summarize(issues);
+  lines.push("");
+  lines.push(`${errors} error(s), ${warnings} warning(s)`);
+  return lines.join("\n");
+}
+function formatJson(issues) {
+  const { errors, warnings } = summarize(issues);
+  return JSON.stringify({ ok: errors === 0, errors, warnings, issues }, null, 2);
+}
+
 // src/server.ts
 import { exec } from "child_process";
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
-import { basename, dirname as dirname2, extname, join as join3, normalize } from "path";
+import { basename as basename2, dirname as dirname2, extname, join as join4, normalize } from "path";
 import { fileURLToPath } from "url";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
 var editorDir = fileURLToPath(new URL("./editor", import.meta.url));
+var PROVIDER_BASE_URLS = {
+  groq: "https://api.groq.com/openai/v1",
+  openrouter: "https://openrouter.ai/api/v1"
+};
+async function callGemini(apiKey, model, system, prompt) {
+  const cleanModel = model.trim().replace(/^models\//, "");
+  const url = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(cleanModel)}:generateContent?key=${encodeURIComponent(apiKey)}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      contents: [{ role: "user", parts: [{ text: prompt }] }],
+      ...system ? { systemInstruction: { parts: [{ text: system }] } } : {}
+    })
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error?.message ?? `Gemini request failed (${res.status})`);
+  const text = data.candidates?.[0]?.content?.parts?.map((p) => p.text ?? "").join("") ?? "";
+  if (!text) throw new Error("Gemini returned an empty response");
+  return text;
+}
+async function listGeminiModels(apiKey) {
+  const url = `https://generativelanguage.googleapis.com/v1beta/models?key=${encodeURIComponent(apiKey)}&pageSize=1000`;
+  const res = await fetch(url);
+  const data = await res.json();
+  if (!res.ok)
+    throw new Error(data.error?.message ?? `Could not fetch the model list (${res.status})`);
+  return (data.models ?? []).filter((m) => m.supportedGenerationMethods?.includes("generateContent")).map((m) => ({
+    id: (m.name ?? "").replace(/^models\//, ""),
+    label: m.displayName ?? (m.name ?? "").replace(/^models\//, "")
+  })).filter(
+    (m) => m.id && !/tts|image|embedding|robotics|computer-use|veo|lyria|imagen|aqa/i.test(m.id)
+  );
+}
+async function listOpenAiCompatibleModels(baseUrl, apiKey) {
+  if (!baseUrl) throw new Error("This provider needs a base URL");
+  const res = await fetch(`${baseUrl.replace(/\/$/, "")}/models`, {
+    headers: apiKey ? { authorization: `Bearer ${apiKey}` } : {}
+  });
+  const data = await res.json();
+  if (!res.ok)
+    throw new Error(data.error?.message ?? `Could not fetch the model list (${res.status})`);
+  return (data.data ?? []).map((m) => ({ id: m.id ?? "", label: m.id ?? "" })).filter((m) => m.id);
+}
+async function callOpenAiCompatible(baseUrl, apiKey, model, system, prompt) {
+  if (!baseUrl) throw new Error("This provider needs a base URL");
+  const messages = [
+    ...system ? [{ role: "system", content: system }] : [],
+    { role: "user", content: prompt }
+  ];
+  const res = await fetch(`${baseUrl.replace(/\/$/, "")}/chat/completions`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+    body: JSON.stringify({ model, messages })
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error?.message ?? `Request failed (${res.status})`);
+  const text = data.choices?.[0]?.message?.content ?? "";
+  if (!text) throw new Error("The provider returned an empty response");
+  return text;
+}
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript",
@@ -4803,15 +5653,16 @@ async function createServer(root2) {
   let store = new ContentStore(adapter, schema, contentDir);
   const app = new Hono();
   app.onError((err, c) => {
-    const msg = err.message;
-    if (msg.startsWith("Bilinmeyen")) return c.json({ error: msg }, 404);
-    if (msg.startsWith("G\xFCvensiz") || msg.startsWith("Yol")) return c.json({ error: msg }, 400);
-    return c.json({ error: "sunucu hatas\u0131" }, 500);
+    if (err instanceof NotFoundError) return c.json({ error: err.message }, 404);
+    if (err instanceof UnsafeSlugError || err instanceof PathEscapeError) {
+      return c.json({ error: err.message }, 400);
+    }
+    return c.json({ error: "server error" }, 500);
   });
   app.get(
     "/api/_project",
     (c) => c.json({
-      name: basename(root2) || "proje",
+      name: basename2(root2) || "project",
       path: root2,
       contentDir,
       collections: schema.collections.length,
@@ -4822,9 +5673,9 @@ async function createServer(root2) {
   app.post("/api/_init", async (c) => {
     const { template: id } = await c.req.json();
     const t = id ? getTemplate(id) : void 0;
-    if (!t) return c.json({ error: "Bilinmeyen template" }, 404);
+    if (!t) return c.json({ error: "Unknown template" }, 404);
     if (schema.collections.length > 0 || schema.singletons.length > 0) {
-      return c.json({ error: "Bu klas\xF6rde zaten bir \u015Fema var." }, 400);
+      return c.json({ error: "This folder already has a schema." }, 400);
     }
     schema = await applyTemplate(adapter, contentDir, t);
     store = new ContentStore(adapter, schema, contentDir);
@@ -4832,7 +5683,7 @@ async function createServer(root2) {
   });
   app.post("/api/_import", async (c) => {
     if (schema.collections.length > 0 || schema.singletons.length > 0) {
-      return c.json({ error: "Bu klas\xF6rde zaten bir \u015Fema var." }, 400);
+      return c.json({ error: "This folder already has a schema." }, 400);
     }
     const { raw } = await c.req.json();
     let next;
@@ -4847,7 +5698,7 @@ async function createServer(root2) {
         entries = inferred.entries;
         singletonData = inferred.singletons;
       } catch (e) {
-        return c.json({ error: `\u0130\xE7e aktar\u0131lamad\u0131: ${e.message}` }, 400);
+        return c.json({ error: `Import failed: ${e.message}` }, 400);
       }
     }
     await saveSchema(adapter, next, contentDir);
@@ -4855,7 +5706,7 @@ async function createServer(root2) {
     store = new ContentStore(adapter, schema, contentDir);
     for (const [collection, rows] of Object.entries(entries)) {
       for (const row of rows) {
-        const slug = slugify(String(row.slug ?? row.title ?? "icerik")) || "icerik";
+        const slug = slugify(String(row.slug ?? row.title ?? "content")) || "content";
         await store.writeEntry(collection, slug, row);
       }
     }
@@ -4897,25 +5748,58 @@ async function createServer(root2) {
   });
   app.post("/api/_media", async (c) => {
     const body = await c.req.json();
-    if (!body.dataBase64) return c.json({ error: "veri yok" }, 400);
+    if (!body.dataBase64) return c.json({ error: "no data" }, 400);
     const base = slugify((body.filename ?? "gorsel").replace(/\.[^.]+$/, "")) || "gorsel";
     const name = `${base}-${Date.now().toString(36)}.webp`;
     const rel = `${contentDir}/media/${name}`;
-    const abs = join3(root2, rel);
+    const abs = join4(root2, rel);
     await mkdir2(dirname2(abs), { recursive: true });
     await writeFile3(abs, Buffer.from(body.dataBase64, "base64"));
     return c.json({ path: rel });
   });
+  app.post("/api/_ai/models", async (c) => {
+    const body = await c.req.json();
+    const { provider, apiKey } = body;
+    if (!provider) return c.json({ error: "provider is required" }, 400);
+    try {
+      const models = provider === "gemini" ? await listGeminiModels(apiKey ?? "") : await listOpenAiCompatibleModels(
+        body.baseUrl || PROVIDER_BASE_URLS[provider] || "",
+        apiKey ?? ""
+      );
+      return c.json({ models });
+    } catch (e) {
+      return c.json({ error: e.message }, 502);
+    }
+  });
+  app.post("/api/_ai/generate", async (c) => {
+    const body = await c.req.json();
+    const { provider, apiKey, model, system, prompt } = body;
+    if (!provider || !apiKey || !model || !prompt) {
+      return c.json({ error: "provider, model, apiKey and prompt are required" }, 400);
+    }
+    try {
+      const text = provider === "gemini" ? await callGemini(apiKey, model, system, prompt) : await callOpenAiCompatible(
+        body.baseUrl || PROVIDER_BASE_URLS[provider] || "",
+        apiKey,
+        model,
+        system,
+        prompt
+      );
+      return c.json({ text });
+    } catch (e) {
+      return c.json({ error: e.message }, 502);
+    }
+  });
   app.get("/media/:file", async (c) => {
     const file = c.req.param("file");
     if (file.includes("/") || file.includes("\\") || file.includes("..")) {
       return c.text("forbidden", 400);
     }
     try {
-      const bytes = await readFile2(join3(root2, contentDir, "media", file));
+      const bytes = await readFile2(join4(root2, contentDir, "media", file));
       return new Response(bytes, { headers: { "content-type": "image/webp" } });
     } catch {
-      return c.text("yok", 404);
+      return c.text("not found", 404);
     }
   });
   app.get("/api/:collection", async (c) => {
@@ -4924,7 +5808,7 @@ async function createServer(root2) {
   });
   app.get("/api/:collection/:slug", async (c) => {
     const data = await store.readEntry(c.req.param("collection"), c.req.param("slug"));
-    return data ? c.json(data) : c.json({ error: "bulunamad\u0131" }, 404);
+    return data ? c.json(data) : c.json({ error: "not found" }, 404);
   });
   app.put("/api/:collection/:slug", async (c) => {
     const slug = slugify(c.req.param("slug"));
@@ -4939,17 +5823,17 @@ async function createServer(root2) {
   app.get("/*", async (c) => {
     const urlPath = c.req.path === "/" ? "/index.html" : c.req.path;
     const rel = normalize(urlPath).replace(/^(\.\.[/\\])+/, "");
-    const file = join3(editorDir, rel);
+    const file = join4(editorDir, rel);
     if (!file.startsWith(editorDir)) return c.text("forbidden", 403);
     const type = MIME[extname(file)] ?? "application/octet-stream";
     try {
       return new Response(await readFile2(file), { headers: { "content-type": type } });
     } catch {
       try {
-        const html = await readFile2(join3(editorDir, "index.html"));
+        const html = await readFile2(join4(editorDir, "index.html"));
         return new Response(html, { headers: { "content-type": "text/html; charset=utf-8" } });
       } catch {
-        return c.text("Edit\xF6r aray\xFCz\xFC bulunamad\u0131 (justjson build gerekli).", 404);
+        return c.text("Editor UI not found (run the justjson build first).", 404);
       }
     }
   });
@@ -4964,27 +5848,44 @@ async function startServer(root2, port) {
   const app = await createServer(root2);
   serve({ fetch: app.fetch, port });
   const url = `http://localhost:${port}`;
-  console.log(`JustJSON \xE7al\u0131\u015F\u0131yor: ${url}`);
+  console.log(`JustJSON is running at ${url}`);
   openBrowser(url);
 }
 
+// src/version.ts
+import { readFileSync } from "fs";
+function readVersion() {
+  const raw = readFileSync(new URL("../package.json", import.meta.url), "utf8");
+  return JSON.parse(raw).version;
+}
+
 // src/cli.ts
 var program = new Command();
 var root = process.cwd();
-program.name("justjson").description("Lokalde \xE7al\u0131\u015Fan, JSON \xFCreten mini CMS").version("0.0.0");
-program.command("init").description("Bir template ile projeyi ba\u015Flat\u0131r").argument("[template]", `template ad\u0131 (${listTemplates().join(", ")})`, "blog").action(async (template) => {
+program.name("justjson").description("A tiny local-first CMS that keeps your content as plain JSON").version(readVersion());
+program.command("init").description("Scaffold a project from a template").argument("[template]", `template name (${listTemplates().join(", ")})`, "blog").action(async (template) => {
   await initProject(root, template);
-  console.log(`'${template}' template'i ile ba\u015Flat\u0131ld\u0131.`);
+  console.log(`Scaffolded from the '${template}' template.`);
 });
-program.command("types").description("\u015Eemadan types.ts \xFCretir").action(async () => {
+program.command("types").description("Generate types.ts and a typed content.ts loader from your schema").action(async () => {
   const out = await generateTypesFile(root);
-  console.log(`Yaz\u0131ld\u0131: ${out}`);
+  console.log(`Wrote: ${out}`);
 });
-program.command("export").description("\u0130\xE7eri\u011Fi ZIP olarak d\u0131\u015Fa aktar\u0131r").action(async () => {
+program.command("export").description("Export schema, content and types as a ZIP").action(async () => {
   const out = await exportZip(root);
-  console.log(`Yaz\u0131ld\u0131: ${out}`);
+  console.log(`Wrote: ${out}`);
+});
+program.command("validate").description("Check your content against the schema (great for CI)").option("--json", "machine-readable JSON output").option("--strict", "treat warnings as errors too").action(async (opts) => {
+  const issues = await validateProjectAt(root);
+  if (issues === null) {
+    console.error("No schema found. Run `justjson init` first.");
+    process.exitCode = 1;
+    return;
+  }
+  console.log(opts.json ? formatJson(issues) : formatText(issues));
+  if (shouldFail(issues, Boolean(opts.strict))) process.exitCode = 1;
 });
-program.command("serve", { isDefault: true }).description("Lokal edit\xF6r sunucusunu ba\u015Flat\u0131r").option("-p, --port <port>", "port", "5180").action(async (opts) => {
+program.command("serve", { isDefault: true }).description("Start the local editor server").option("-p, --port <port>", "port", "5180").action(async (opts) => {
   await startServer(root, Number(opts.port));
 });
 program.parseAsync();