@kdrgny/justjson 1.2.0 → 1.6.0

package/dist/cli.js

@@ -6,11 +6,7 @@ var __export = (target, all) => {
 };
 
 // src/cli.ts
-import { Command } from "commander";
-
-// src/commands/export.ts
-import { writeFile as writeFile2 } from "fs/promises";
-import { join } from "path";
+import { basename as basename3 } from "path";
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -4054,6 +4050,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 +4072,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 +4123,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 +4178,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 +4200,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 +4222,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 +4280,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 +4492,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 +4514,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 +4526,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 +4643,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 +4652,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,14 +4701,19 @@ 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 };
 }
 
+// src/cli.ts
+import { Command } from "commander";
+
 // src/commands/export.ts
+import { writeFile as writeFile2 } from "fs/promises";
+import { join } from "path";
 import { zipSync } from "fflate";
 
 // src/fs-adapter.ts
@@ -4422,7 +4728,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 +4787,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,109 +4824,194 @@ 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: "\u0130lk yaz\u0131", slug: "ilk-yazi", body: "Merhaba." }]
+    posts: [
+      {
+        title: "First post",
+        slug: "first-post",
+        body: "Hello."
+      }
+    ],
+    settings: {
+      title: "My blog"
+    }
   }
 };
 
 // src/templates/catalog.json
 var catalog_default = {
-  title: "\xDCr\xFCn Katalo\u011Fu",
-  description: "Fiyat, kategori ve g\xF6rselli \xFCr\xFCnler; bir de Ma\u011Faza ayarlar\u0131.",
+  title: "Product catalog",
+  description: "Products with price, category and an image, plus Store settings.",
   schema: {
     version: 1,
     collections: [
       {
-        name: "urunler",
-        label: "\xDCr\xFCnler",
-        path: "urunler",
+        name: "products",
+        label: "Products",
+        path: "products",
         fields: [
-          { key: "title", label: "Ba\u015Fl\u0131k", type: "text", required: true },
-          { key: "slug", label: "Slug", type: "text", required: true },
-          { key: "fiyat", label: "Fiyat", type: "number" },
           {
-            key: "kategori",
-            label: "Kategori",
+            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: ["Ev", "Giyim", "Aksesuar"]
+            options: ["Home", "Clothing", "Accessories"]
+          },
+          {
+            key: "cover",
+            label: "Image",
+            type: "image"
           },
-          { key: "kapak", label: "G\xF6rsel", type: "image" },
-          { key: "aciklama", label: "A\xE7\u0131klama", type: "richtext" }
+          {
+            key: "description",
+            label: "Description",
+            type: "richtext"
+          }
         ]
       }
     ],
     singletons: [
       {
-        name: "magaza",
-        label: "Ma\u011Faza",
-        path: "magaza.json",
+        name: "store",
+        label: "Store",
+        path: "store.json",
         fields: [
-          { key: "title", label: "Ma\u011Faza ad\u0131", type: "text" },
-          { key: "slogan", label: "Slogan", type: "text" }
+          {
+            key: "title",
+            label: "Store name",
+            type: "text"
+          },
+          {
+            key: "tagline",
+            label: "Tagline",
+            type: "text"
+          }
         ]
       }
     ]
   },
   samples: {
-    urunler: [
+    products: [
       {
-        title: "Seramik Kupa",
-        slug: "seramik-kupa",
-        fiyat: 180,
-        kategori: "Ev",
-        aciklama: "Elde yap\u0131m seramik kupa."
+        title: "Ceramic mug",
+        slug: "ceramic-mug",
+        price: 18,
+        category: "Home",
+        description: "Hand-made ceramic mug."
       }
-    ]
+    ],
+    store: {
+      title: "My store",
+      tagline: "Small batch, made well"
+    }
   }
 };
 
 // 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"
+          }
         ]
       }
     ],
@@ -4631,8 +5022,8 @@ var changelog_default = {
       {
         version: "1.0.0",
         slug: "1-0-0",
-        type: "Eklendi",
-        body: "\u0130lk s\xFCr\xFCm."
+        type: "Added",
+        body: "First release."
       }
     ]
   }
@@ -4641,161 +5032,314 @@ 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: "..."
+      }
+    ],
+    profile: {
+      name: "Ada Lovelace",
+      headline: "Software engineer"
+    }
   }
 };
 
 // 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."
+      }
+    ],
+    settings: {
+      title: "Docs",
+      tagline: "Everything you need to know"
+    }
   }
 };
 
 // src/templates/event.json
 var event_default = {
-  title: "Etkinlik Program\u0131",
-  description: "Tarih, saat ve konu\u015Fmac\u0131l\u0131 oturumlardan olu\u015Fan bir etkinlik ajandas\u0131.",
+  title: "Event schedule",
+  description: "An event agenda of sessions with date, time and speaker.",
   schema: {
     version: 1,
     collections: [
       {
-        name: "oturumlar",
-        label: "Oturumlar",
-        path: "oturumlar",
+        name: "sessions",
+        label: "Sessions",
+        path: "sessions",
         fields: [
-          { key: "title", label: "Ba\u015Fl\u0131k", type: "text", required: true },
-          { key: "slug", label: "Slug", type: "text", required: true },
-          { key: "tarih", label: "Tarih", type: "date" },
-          { key: "saat", label: "Saat", type: "text" },
-          { key: "konusmaci", label: "Konu\u015Fmac\u0131", type: "text" },
-          { key: "yer", label: "Salon", type: "text" },
-          { key: "aciklama", label: "A\xE7\u0131klama", 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: "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: "etkinlik",
-        label: "Etkinlik",
-        path: "etkinlik.json",
+        name: "event",
+        label: "Event",
+        path: "event.json",
         fields: [
-          { key: "title", label: "Etkinlik ad\u0131", type: "text" },
-          { key: "slogan", label: "Slogan", type: "text" }
+          {
+            key: "title",
+            label: "Event name",
+            type: "text"
+          },
+          {
+            key: "tagline",
+            label: "Tagline",
+            type: "text"
+          }
         ]
       }
     ]
   },
   samples: {
-    oturumlar: [
+    sessions: [
       {
-        title: "A\xE7\u0131l\u0131\u015F Konu\u015Fmas\u0131",
-        slug: "acilis-konusmasi",
-        saat: "09:00",
-        konusmaci: "Ay\u015Fe Y\u0131lmaz",
-        yer: "Ana Salon",
-        aciklama: "Etkinli\u011Fe ho\u015F geldiniz."
+        title: "Opening keynote",
+        slug: "opening-keynote",
+        time: "09:00",
+        speaker: "Ada Lovelace",
+        room: "Main hall",
+        description: "Welcome to the event."
       }
-    ]
+    ],
+    event: {
+      title: "My event",
+      tagline: "One day, one track"
+    }
   }
 };
 
 // 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: "\u0130\xE7erik", type: "richtext" },
-          { key: "date", label: "Tarih", type: "date" }
+          {
+            key: "body",
+            label: "Body",
+            type: "richtext"
+          },
+          {
+            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"
+          }
         ]
       }
     ]
@@ -4803,58 +5347,101 @@ 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."
       }
-    ]
+    ],
+    about: {
+      name: "Ada Lovelace",
+      bio: "I build things for the web."
+    }
   }
 };
 
 // src/templates/recipe.json
 var recipe_default = {
-  title: "Tarif Defteri",
-  description: "Malzeme, yap\u0131l\u0131\u015F ve kapak g\xF6rselli tarifler; bir de Mutfak ayarlar\u0131.",
+  title: "Recipe box",
+  description: "Recipes with ingredients, steps and a cover image, plus Kitchen settings.",
   schema: {
     version: 1,
     collections: [
       {
-        name: "tarifler",
-        label: "Tarifler",
-        path: "tarifler",
+        name: "recipes",
+        label: "Recipes",
+        path: "recipes",
         fields: [
-          { key: "title", label: "Ba\u015Fl\u0131k", type: "text", required: true },
-          { key: "slug", label: "Slug", type: "text", required: true },
-          { key: "sure", label: "S\xFCre", type: "text" },
-          { key: "porsiyon", label: "Porsiyon", type: "number" },
-          { key: "kapak", label: "Kapak", type: "image" },
-          { key: "malzemeler", label: "Malzemeler", type: "richtext" },
-          { key: "yapilis", label: "Yap\u0131l\u0131\u015F", type: "richtext" }
+          {
+            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: "mutfak",
-        label: "Mutfak",
-        path: "mutfak.json",
-        fields: [{ key: "title", label: "Site ad\u0131", type: "text" }]
+        name: "kitchen",
+        label: "Kitchen",
+        path: "kitchen.json",
+        fields: [
+          {
+            key: "title",
+            label: "Site name",
+            type: "text"
+          }
+        ]
       }
     ]
   },
   samples: {
-    tarifler: [
+    recipes: [
       {
-        title: "Ak\u015Fam Makarnas\u0131",
-        slug: "aksam-makarnasi",
-        sure: "20 dk",
-        porsiyon: 2,
-        malzemeler: "- 200g makarna\n- 2 di\u015F sar\u0131msak\n- Zeytinya\u011F\u0131",
-        yapilis: "Makarnay\u0131 ha\u015Fla. Sar\u0131msa\u011F\u0131 zeytinya\u011F\u0131nda kavur. Kar\u0131\u015Ft\u0131r."
+        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."
       }
-    ]
+    ],
+    kitchen: {
+      title: "My recipe box"
+    }
   }
 };
 
@@ -4894,10 +5481,15 @@ async function applyTemplate(adapter, contentDir, template) {
   const schema = parseSchema(template.schema);
   await saveSchema(adapter, schema, contentDir);
   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"));
-      await store.writeEntry(collection, slug, row);
+  const singletonNames = new Set(schema.singletons.map((s) => s.name));
+  for (const [name, sample] of Object.entries(template.samples)) {
+    if (!Array.isArray(sample)) {
+      if (singletonNames.has(name)) await store.writeSingleton(name, sample);
+      continue;
+    }
+    for (const row of sample) {
+      const slug = slugify(typeof row.slug === "string" ? row.slug : String(row.title ?? "content"));
+      await store.writeEntry(name, slug, row);
     }
   }
   return schema;
@@ -4908,29 +5500,402 @@ 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/scaffold.ts
+import { access, mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join4 } from "path";
+var ASTRO_VERSION = "^5.18.0";
+var LOADER_VERSION = "^1.6.0";
+var STYLE = `  <style is:global>
+    :root { color-scheme: light dark; }
+    body {
+      margin: 0 auto;
+      max-width: 44rem;
+      padding: 3rem 1.25rem 6rem;
+      font: 16px/1.65 ui-sans-serif, system-ui, sans-serif;
+    }
+    h1 { font-size: 1.9rem; line-height: 1.2; margin: 0 0 0.35rem; }
+    h2 { font-size: 1.05rem; text-transform: uppercase; letter-spacing: 0.08em; opacity: 0.6; margin: 2.75rem 0 0.75rem; }
+    ul { list-style: none; margin: 0; padding: 0; }
+    li + li { margin-top: 0.6rem; }
+    a { color: inherit; }
+    time { opacity: 0.6; font-size: 0.9rem; }
+    img { max-width: 100%; height: auto; border-radius: 8px; }
+    .body { white-space: pre-wrap; }
+  </style>`;
+function titleFieldOf(fields) {
+  const preferred = fields.find(
+    (f) => ["title", "name", "label", "role", "version"].includes(f.key)
+  );
+  return (preferred ?? fields.find((f) => f.type === "text"))?.key ?? "title";
+}
+function safePackageName(name) {
+  return slugify(name) || "my-site";
+}
+function detailPage(collection) {
+  const titleKey = titleFieldOf(collection.fields);
+  const image = collection.fields.find((f) => f.type === "image");
+  const rich = collection.fields.find((f) => f.type === "richtext");
+  const date = collection.fields.find((f) => f.type === "date");
+  const parts = [
+    `<h1>{entry.data.${titleKey} ?? entry.id}</h1>`,
+    date && `{entry.data.${date.key} && <time>{entry.data.${date.key}}</time>}`,
+    image && `{entry.data.${image.key} && <img src={\`/media/\${entry.data.${image.key}.split('/').pop()}\`} alt="" />}`,
+    rich && `{entry.data.${rich.key} && <div class="body">{entry.data.${rich.key}}</div>}`
+  ].filter(Boolean);
+  return `---
+import { getCollection } from 'astro:content'
+
+export async function getStaticPaths() {
+  const entries = await getCollection('${collection.name}')
+  return entries.map((entry) => ({ params: { slug: entry.id }, props: { entry } }))
+}
+
+const { entry } = Astro.props
+---
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>{entry.data.${titleKey} ?? entry.id}</title>
+${STYLE}
+  </head>
+  <body>
+    <p><a href="/">&larr; Back</a></p>
+${parts.map((p) => `    ${p}`).join("\n")}
+  </body>
+</html>
+`;
+}
+function indexPage(schema, projectName) {
+  const singleton = schema.singletons[0];
+  const imports = ["getCollection", singleton && "getEntry"].filter(Boolean).join(", ");
+  const loads = schema.collections.map(
+    (c) => `const ${varFor(c.name)} = await getCollection('${c.name}')`
+  );
+  if (singleton) {
+    loads.unshift(`const site = await getEntry('${singleton.name}', '${singleton.name}')`);
+  }
+  const heading = singleton ? `{site?.data.${titleFieldOf(singleton.fields)} ?? '${projectName}'}` : `${projectName}`;
+  const sections = schema.collections.map((c) => {
+    const titleKey = titleFieldOf(c.fields);
+    return `    <h2>${c.label ?? c.name}</h2>
+    <ul>
+      {${varFor(c.name)}.map((entry) => (
+        <li>
+          <a href={\`/${c.name}/\${entry.id}\`}>{entry.data.${titleKey} ?? entry.id}</a>
+        </li>
+      ))}
+    </ul>`;
+  });
+  const empty = `    <p>No content yet \u2014 run <code>npx @kdrgny/justjson</code> and add some.</p>`;
+  return `---
+import { ${imports} } from 'astro:content'
+
+${loads.join("\n")}
+---
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${singleton ? `{site?.data.${titleFieldOf(singleton.fields)} ?? '${projectName}'}` : projectName}</title>
+${STYLE}
+  </head>
+  <body>
+    <h1>${heading}</h1>
+${sections.length ? sections.join("\n") : empty}
+  </body>
+</html>
+`;
+}
+function varFor(name) {
+  const camel = name.replace(/[^a-zA-Z0-9]+(.)/g, (_, c) => c.toUpperCase());
+  return /^[a-zA-Z_$]/.test(camel) ? camel : `c${camel}`;
+}
+function astroSiteFiles(schema, projectName) {
+  const files = {
+    "package.json": `${JSON.stringify(
+      {
+        name: safePackageName(projectName),
+        type: "module",
+        version: "0.0.1",
+        private: true,
+        scripts: { dev: "astro dev", build: "astro build", preview: "astro preview" },
+        dependencies: {
+          "@kdrgny/justjson-astro": LOADER_VERSION,
+          astro: ASTRO_VERSION
+        }
+      },
+      null,
+      2
+    )}
+`,
+    "astro.config.mjs": `import { defineConfig } from 'astro/config'
+
+export default defineConfig({})
+`,
+    "tsconfig.json": `${JSON.stringify({ extends: "astro/tsconfigs/strict" }, null, 2)}
+`,
+    ".gitignore": `node_modules
+dist
+.astro
+`,
+    "src/content.config.ts": `import { justjsonCollections } from '@kdrgny/justjson-astro'
+
+// Every collection and singleton in content/_schema.json, typed from your fields.
+export const collections = await justjsonCollections()
+`,
+    "src/pages/index.astro": indexPage(schema, projectName)
+  };
+  for (const collection of schema.collections) {
+    files[`src/pages/${collection.name}/[slug].astro`] = detailPage(collection);
+  }
+  return files;
+}
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeAstroSite(root2, schema, projectName) {
+  const files = astroSiteFiles(schema, projectName);
+  const result = { written: [], skipped: [] };
+  for (const [relative, contents] of Object.entries(files)) {
+    const target = join4(root2, relative);
+    if (await exists(target)) {
+      result.skipped.push(relative);
+      continue;
+    }
+    await mkdir2(dirname2(target), { recursive: true });
+    await writeFile3(target, contents, "utf8");
+    result.written.push(relative);
+  }
+  return result;
+}
+
 // 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 { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
+import { basename as basename2, dirname as dirname3, extname, join as join6, normalize } from "path";
 import { fileURLToPath } from "url";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
+
+// src/detect.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join5 } from "path";
+var SIGNATURES = [
+  ["astro", "astro"],
+  ["next", "next"],
+  ["nuxt", "nuxt"],
+  ["sveltekit", "@sveltejs/kit"],
+  ["vite", "vite"]
+];
+async function detectFramework(root2) {
+  let pkg;
+  try {
+    pkg = JSON.parse(await readFile2(join5(root2, "package.json"), "utf8"));
+  } catch {
+    return "unknown";
+  }
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  for (const [framework, dependency] of SIGNATURES) {
+    if (deps[dependency]) return framework;
+  }
+  return "node";
+}
+
+// src/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var run = promisify(execFile);
+async function git(root2, args) {
+  const { stdout } = await run("git", args, { cwd: root2 });
+  return stdout.trim();
+}
+async function tryGit(root2, args) {
+  try {
+    return await git(root2, args);
+  } catch {
+    return null;
+  }
+}
+async function hasGh() {
+  try {
+    await run("gh", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function gitStatus(root2, contentDir) {
+  const inside = await tryGit(root2, ["rev-parse", "--is-inside-work-tree"]);
+  if (inside !== "true") {
+    return {
+      isRepo: false,
+      branch: null,
+      hasRemote: false,
+      remoteUrl: null,
+      pendingFiles: 0,
+      hasGh: await hasGh()
+    };
+  }
+  const branch = await tryGit(root2, ["branch", "--show-current"]);
+  const remoteUrl = await tryGit(root2, ["remote", "get-url", "origin"]);
+  const porcelain = await tryGit(root2, ["status", "--porcelain", "-uall", "--", contentDir]) ?? "";
+  return {
+    isRepo: true,
+    branch: branch || null,
+    hasRemote: remoteUrl !== null,
+    remoteUrl,
+    pendingFiles: porcelain ? porcelain.split("\n").filter(Boolean).length : 0,
+    hasGh: await hasGh()
+  };
+}
+async function commitContent(root2, contentDir, message) {
+  const inside = await tryGit(root2, ["rev-parse", "--is-inside-work-tree"]);
+  if (inside !== "true") throw new Error("Not a git repository \u2014 run `git init` first.");
+  await git(root2, ["add", "--", contentDir]);
+  const staged = await tryGit(root2, ["diff", "--cached", "--name-only", "--", contentDir]);
+  if (!staged) return { committed: false, count: 0 };
+  await git(root2, ["commit", "-m", message, "--", contentDir]);
+  return { committed: true, count: staged.split("\n").filter(Boolean).length };
+}
+async function pushContent(root2) {
+  const branch = await tryGit(root2, ["branch", "--show-current"]);
+  if (!branch || branch === "HEAD") throw new Error("No branch to push \u2014 commit something first.");
+  const hasUpstream = await tryGit(root2, ["rev-parse", "--abbrev-ref", `${branch}@{upstream}`]);
+  const args = hasUpstream ? ["push"] : ["push", "-u", "origin", branch];
+  await git(root2, args);
+  return { branch };
+}
+async function createGitHubRepo(root2, options) {
+  if (!await hasGh()) {
+    throw new Error("GitHub CLI (gh) not found \u2014 install it, or add a remote yourself.");
+  }
+  const inside = await tryGit(root2, ["rev-parse", "--is-inside-work-tree"]);
+  if (inside !== "true") {
+    await git(root2, ["init", "-b", "main"]);
+  }
+  await run(
+    "gh",
+    [
+      "repo",
+      "create",
+      options.name,
+      options.private ? "--private" : "--public",
+      "--source",
+      ".",
+      "--push"
+    ],
+    {
+      cwd: root2
+    }
+  );
+  return { name: options.name };
+}
+
+// src/server.ts
 var editorDir = fileURLToPath(new URL("./editor", import.meta.url));
 var PROVIDER_BASE_URLS = {
   groq: "https://api.groq.com/openai/v1",
@@ -4948,16 +5913,17 @@ async function callGemini(apiKey, model, system, prompt) {
     })
   });
   const data = await res.json();
-  if (!res.ok) throw new Error(data.error?.message ?? `Gemini iste\u011Fi ba\u015Far\u0131s\u0131z (${res.status})`);
+  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 bo\u015F yan\u0131t d\xF6nd\xFC");
+  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 ?? `Model listesi al\u0131namad\u0131 (${res.status})`);
+  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\//, "")
@@ -4966,16 +5932,17 @@ async function listGeminiModels(apiKey) {
   );
 }
 async function listOpenAiCompatibleModels(baseUrl, apiKey) {
-  if (!baseUrl) throw new Error("Bu sa\u011Flay\u0131c\u0131 i\xE7in taban URL gerekli");
+  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 ?? `Model listesi al\u0131namad\u0131 (${res.status})`);
+  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("Bu sa\u011Flay\u0131c\u0131 i\xE7in taban URL gerekli");
+  if (!baseUrl) throw new Error("This provider needs a base URL");
   const messages = [
     ...system ? [{ role: "system", content: system }] : [],
     { role: "user", content: prompt }
@@ -4986,9 +5953,9 @@ async function callOpenAiCompatible(baseUrl, apiKey, model, system, prompt) {
     body: JSON.stringify({ model, messages })
   });
   const data = await res.json();
-  if (!res.ok) throw new Error(data.error?.message ?? `\u0130stek ba\u015Far\u0131s\u0131z (${res.status})`);
+  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("Sa\u011Flay\u0131c\u0131 bo\u015F yan\u0131t d\xF6nd\xFC");
+  if (!text) throw new Error("The provider returned an empty response");
   return text;
 }
 var MIME = {
@@ -5009,28 +5976,68 @@ 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,
       singletons: schema.singletons.length
     })
   );
+  app.post("/api/_ship/scaffold", async (c) => {
+    if (schema.collections.length === 0 && schema.singletons.length === 0) {
+      return c.json({ error: "Pick a template or build a schema first." }, 400);
+    }
+    return c.json(await writeAstroSite(root2, schema, basename2(root2) || "my-site"));
+  });
+  app.get(
+    "/api/_ship",
+    async (c) => c.json({
+      framework: await detectFramework(root2),
+      git: await gitStatus(root2, contentDir)
+    })
+  );
+  app.post("/api/_ship/commit", async (c) => {
+    const { message } = await c.req.json();
+    try {
+      return c.json(await commitContent(root2, contentDir, message?.trim() || "content: update"));
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+  });
+  app.post("/api/_ship/push", async (c) => {
+    try {
+      return c.json(await pushContent(root2));
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+  });
+  app.post("/api/_ship/repo", async (c) => {
+    const { name, private: isPrivate } = await c.req.json();
+    if (!name?.trim()) return c.json({ error: "A repository name is required." }, 400);
+    try {
+      return c.json(
+        await createGitHubRepo(root2, { name: name.trim(), private: isPrivate !== false })
+      );
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+  });
   app.get("/api/_templates", (c) => c.json({ items: templateList() }));
   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);
@@ -5038,7 +6045,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;
@@ -5053,7 +6060,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);
@@ -5061,7 +6068,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);
       }
     }
@@ -5103,19 +6110,19 @@ 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);
-    await mkdir2(dirname2(abs), { recursive: true });
-    await writeFile3(abs, Buffer.from(body.dataBase64, "base64"));
+    const abs = join6(root2, rel);
+    await mkdir3(dirname3(abs), { recursive: true });
+    await writeFile4(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 zorunlu" }, 400);
+    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] || "",
@@ -5130,7 +6137,7 @@ async function createServer(root2) {
     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 ve prompt zorunlu" }, 400);
+      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(
@@ -5151,10 +6158,10 @@ async function createServer(root2) {
       return c.text("forbidden", 400);
     }
     try {
-      const bytes = await readFile2(join3(root2, contentDir, "media", file));
+      const bytes = await readFile3(join6(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) => {
@@ -5163,7 +6170,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"));
@@ -5178,17 +6185,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 = join6(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 } });
+      return new Response(await readFile3(file), { headers: { "content-type": type } });
     } catch {
       try {
-        const html = await readFile2(join3(editorDir, "index.html"));
+        const html = await readFile3(join6(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);
       }
     }
   });
@@ -5203,27 +6210,51 @@ 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").option("--astro", "also generate a working Astro site around the content").action(async (template, opts) => {
   await initProject(root, template);
-  console.log(`'${template}' template'i ile ba\u015Flat\u0131ld\u0131.`);
+  console.log(`Scaffolded from the '${template}' template.`);
+  if (!opts.astro) return;
+  const schema = await loadSchema(new FsAdapter(root), await resolveContentDir(root));
+  if (!schema) return;
+  const { written, skipped } = await writeAstroSite(root, schema, basename3(root) || "my-site");
+  console.log(`Wrote ${written.length} site file(s).`);
+  if (skipped.length > 0) console.log(`Kept your existing: ${skipped.join(", ")}`);
+  console.log("\nNext:\n  npm install\n  npm run dev");
 });
-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();