fimo 0.3.1 → 0.3.2

package/dist/cli/bundle.json

@@ -1,8 +1,8 @@
 {
   "bundled": true,
   "bundler": "esbuild",
-  "bundledAt": "2026-07-02T16:18:34.112Z",
-  "cliVersion": "0.3.1",
+  "bundledAt": "2026-07-02T20:33:21.698Z",
+  "cliVersion": "0.3.2",
   "external": [
     "oxc-parser",
     "fsevents"

package/dist/cli/index.js

@@ -17313,20 +17313,20 @@ var require_parse_async = __commonJS({
       const index2 = 0;
       const blocksize = opts.blocksize || 40960;
       const parser = new TOMLParser();
-      return new Promise((resolve7, reject) => {
-        setImmediate(parseAsyncNext, index2, blocksize, resolve7, reject);
+      return new Promise((resolve8, reject) => {
+        setImmediate(parseAsyncNext, index2, blocksize, resolve8, reject);
       });
-      function parseAsyncNext(index3, blocksize2, resolve7, reject) {
+      function parseAsyncNext(index3, blocksize2, resolve8, reject) {
         if (index3 >= str.length) {
           try {
-            return resolve7(parser.finish());
+            return resolve8(parser.finish());
           } catch (err) {
             return reject(prettyError(err, str));
           }
         }
         try {
           parser.parse(str.slice(index3, index3 + blocksize2));
-          setImmediate(parseAsyncNext, index3 + blocksize2, blocksize2, resolve7, reject);
+          setImmediate(parseAsyncNext, index3 + blocksize2, blocksize2, resolve8, reject);
         } catch (err) {
           reject(prettyError(err, str));
         }
@@ -17355,7 +17355,7 @@ var require_parse_stream = __commonJS({
     function parseReadable(stm) {
       const parser = new TOMLParser();
       stm.setEncoding("utf8");
-      return new Promise((resolve7, reject) => {
+      return new Promise((resolve8, reject) => {
         let readable;
         let ended = false;
         let errored = false;
@@ -17363,7 +17363,7 @@ var require_parse_stream = __commonJS({
           ended = true;
           if (readable) return;
           try {
-            resolve7(parser.finish());
+            resolve8(parser.finish());
           } catch (err) {
             reject(err);
           }
@@ -41851,7 +41851,7 @@ var init_pagination = __esm({
 });
 
 // ../../packages/api-contracts/dist/esm/types/common.js
-var CommonSchemas, BaseEntitySchema, ProjectRoleKeySchema, ProjectRoleKeyWithSystemSchema, ProjectPrincipalTypeSchema, ProjectVisibilitySchema, ProjectStatusSchema, ProjectInviteStatusSchema, PublicationStatusSchema, OrganizationRoleSchema, AssetTypeSchema, TemplateCodeSchema, FieldTypeSchema;
+var CommonSchemas, BaseEntitySchema, ProjectRoleKeySchema, ProjectRoleKeyWithSystemSchema, ProjectPrincipalTypeSchema, ProjectVisibilitySchema, ProjectStatusSchema, ProjectInviteStatusSchema, PublicationStatusSchema, OrganizationRoleSchema, AssetTypeSchema, TemplateCodeSchema, FieldTypeSchema, RESERVED_CONTENT_FIELD_NAMES;
 var init_common = __esm({
   "../../packages/api-contracts/dist/esm/types/common.js"() {
     "use strict";
@@ -41932,6 +41932,15 @@ var init_common = __esm({
       "date",
       "json"
     ]);
+    RESERVED_CONTENT_FIELD_NAMES = [
+      "id",
+      "documentId",
+      "slug",
+      "locale",
+      "createdAt",
+      "updatedAt",
+      "__fimo"
+    ];
   }
 });
 
@@ -69995,9 +70004,9 @@ var require_dispatcher_base = __commonJS({
       }
       close(callback) {
         if (callback === void 0) {
-          return new Promise((resolve7, reject) => {
+          return new Promise((resolve8, reject) => {
             this.close((err, data2) => {
-              return err ? reject(err) : resolve7(data2);
+              return err ? reject(err) : resolve8(data2);
             });
           });
         }
@@ -70035,9 +70044,9 @@ var require_dispatcher_base = __commonJS({
           err = null;
         }
         if (callback === void 0) {
-          return new Promise((resolve7, reject) => {
+          return new Promise((resolve8, reject) => {
             this.destroy(err, (err2, data2) => {
-              return err2 ? reject(err2) : resolve7(data2);
+              return err2 ? reject(err2) : resolve8(data2);
             });
           });
         }
@@ -73627,8 +73636,8 @@ var require_promise = __commonJS({
     function createDeferredPromise() {
       let res;
       let rej;
-      const promise2 = new Promise((resolve7, reject) => {
-        res = resolve7;
+      const promise2 = new Promise((resolve8, reject) => {
+        res = resolve8;
         rej = reject;
       });
       return { promise: promise2, resolve: res, reject: rej };
@@ -74957,12 +74966,12 @@ upgrade: ${upgrade}\r
         }
       }
       __name(onDrain, "onDrain");
-      const waitForDrain = /* @__PURE__ */ __name(() => new Promise((resolve7, reject) => {
+      const waitForDrain = /* @__PURE__ */ __name(() => new Promise((resolve8, reject) => {
         assert2(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve7;
+          callback = resolve8;
         }
       }), "waitForDrain");
       socket.on("close", onDrain).on("drain", onDrain);
@@ -75835,12 +75844,12 @@ var require_client_h2 = __commonJS({
         }
       }
       __name(onDrain, "onDrain");
-      const waitForDrain = /* @__PURE__ */ __name(() => new Promise((resolve7, reject) => {
+      const waitForDrain = /* @__PURE__ */ __name(() => new Promise((resolve8, reject) => {
         assert2(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve7;
+          callback = resolve8;
         }
       }), "waitForDrain");
       h2stream.on("close", onDrain).on("drain", onDrain);
@@ -76156,16 +76165,16 @@ var require_client = __commonJS({
         return this[kNeedDrain] < 2;
       }
       [kClose]() {
-        return new Promise((resolve7) => {
+        return new Promise((resolve8) => {
           if (this[kSize]) {
-            this[kClosedResolve] = resolve7;
+            this[kClosedResolve] = resolve8;
           } else {
-            resolve7(null);
+            resolve8(null);
           }
         });
       }
       [kDestroy](err) {
-        return new Promise((resolve7) => {
+        return new Promise((resolve8) => {
           const requests = this[kQueue].splice(this[kPendingIdx]);
           for (let i = 0; i < requests.length; i++) {
             const request = requests[i];
@@ -76176,7 +76185,7 @@ var require_client = __commonJS({
               this[kClosedResolve]();
               this[kClosedResolve] = null;
             }
-            resolve7(null);
+            resolve8(null);
           }, "callback");
           if (this[kHTTPContext]) {
             this[kHTTPContext].destroy(err, callback);
@@ -76596,8 +76605,8 @@ var require_pool_base = __commonJS({
           }
           return Promise.all(closeAll);
         } else {
-          return new Promise((resolve7) => {
-            this[kClosedResolve] = resolve7;
+          return new Promise((resolve8) => {
+            this[kClosedResolve] = resolve8;
           });
         }
       }
@@ -77717,10 +77726,10 @@ var require_socks5_proxy_agent = __commonJS({
         const proxyHost = this[kProxyUrl].hostname;
         const proxyPort = parseInt(this[kProxyUrl].port) || 1080;
         debug("creating SOCKS5 connection to", proxyHost, proxyPort);
-        const socket = await new Promise((resolve7, reject) => {
+        const socket = await new Promise((resolve8, reject) => {
           const onConnect = /* @__PURE__ */ __name(() => {
             socket2.removeListener("error", onError);
-            resolve7(socket2);
+            resolve8(socket2);
           }, "onConnect");
           const onError = /* @__PURE__ */ __name((err) => {
             socket2.removeListener("connect", onConnect);
@@ -77739,14 +77748,14 @@ var require_socks5_proxy_agent = __commonJS({
           socket.destroy();
         });
         await socks5Client.handshake();
-        await new Promise((resolve7, reject) => {
+        await new Promise((resolve8, reject) => {
           const timeout = setTimeout(() => {
             reject(new Error("SOCKS5 authentication timeout"));
           }, 5e3);
           const onAuthenticated = /* @__PURE__ */ __name(() => {
             clearTimeout(timeout);
             socks5Client.removeListener("error", onError);
-            resolve7();
+            resolve8();
           }, "onAuthenticated");
           const onError = /* @__PURE__ */ __name((err) => {
             clearTimeout(timeout);
@@ -77755,14 +77764,14 @@ var require_socks5_proxy_agent = __commonJS({
           }, "onError");
           if (socks5Client.state === "authenticated") {
             clearTimeout(timeout);
-            resolve7();
+            resolve8();
           } else {
             socks5Client.once("authenticated", onAuthenticated);
             socks5Client.once("error", onError);
           }
         });
         await socks5Client.connect(targetHost, targetPort);
-        await new Promise((resolve7, reject) => {
+        await new Promise((resolve8, reject) => {
           const timeout = setTimeout(() => {
             reject(new Error("SOCKS5 connection timeout"));
           }, 5e3);
@@ -77770,7 +77779,7 @@ var require_socks5_proxy_agent = __commonJS({
             debug("SOCKS5 tunnel established to", targetHost, targetPort, "via", info);
             clearTimeout(timeout);
             socks5Client.removeListener("error", onError);
-            resolve7();
+            resolve8();
           }, "onConnected");
           const onError = /* @__PURE__ */ __name((err) => {
             clearTimeout(timeout);
@@ -77811,8 +77820,8 @@ var require_socks5_proxy_agent = __commonJS({
                       servername: targetHost,
                       ...connectOpts.tls || {}
                     });
-                    await new Promise((resolve7, reject) => {
-                      finalSocket.once("secureConnect", resolve7);
+                    await new Promise((resolve8, reject) => {
+                      finalSocket.once("secureConnect", resolve8);
                       finalSocket.once("error", reject);
                     });
                   }
@@ -78866,7 +78875,7 @@ var require_readable = __commonJS({
         if (this._readableState.closeEmitted) {
           return Promise.resolve(null);
         }
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve8, reject) => {
           if (this[kContentLength] && this[kContentLength] > limit || this[kBytesRead] > limit) {
             this.destroy(new AbortError());
           }
@@ -78880,11 +78889,11 @@ var require_readable = __commonJS({
               if (signal.aborted) {
                 reject(signal.reason ?? new AbortError());
               } else {
-                resolve7(null);
+                resolve8(null);
               }
             });
           } else {
-            this.on("close", resolve7);
+            this.on("close", resolve8);
           }
           this.on("error", noop).on("data", () => {
             if (this[kBytesRead] > limit) {
@@ -78914,7 +78923,7 @@ var require_readable = __commonJS({
     __name(isUnusable, "isUnusable");
     function consume(stream, type) {
       assert2(!stream[kConsume]);
-      return new Promise((resolve7, reject) => {
+      return new Promise((resolve8, reject) => {
         if (isUnusable(stream)) {
           const rState = stream._readableState;
           if (rState.destroyed && rState.closeEmitted === false) {
@@ -78929,7 +78938,7 @@ var require_readable = __commonJS({
             stream[kConsume] = {
               type,
               stream,
-              resolve: resolve7,
+              resolve: resolve8,
               reject,
               length: 0,
               body: []
@@ -79007,18 +79016,18 @@ var require_readable = __commonJS({
     }
     __name(chunksConcat, "chunksConcat");
     function consumeEnd(consume2, encoding) {
-      const { type, body, resolve: resolve7, stream, length } = consume2;
+      const { type, body, resolve: resolve8, stream, length } = consume2;
       try {
         if (type === "text") {
-          resolve7(chunksDecode(body, length, encoding));
+          resolve8(chunksDecode(body, length, encoding));
         } else if (type === "json") {
-          resolve7(JSON.parse(chunksDecode(body, length, encoding)));
+          resolve8(JSON.parse(chunksDecode(body, length, encoding)));
         } else if (type === "arrayBuffer") {
-          resolve7(chunksConcat(body, length).buffer);
+          resolve8(chunksConcat(body, length).buffer);
         } else if (type === "blob") {
-          resolve7(new Blob(body, { type: stream[kContentType] }));
+          resolve8(new Blob(body, { type: stream[kContentType] }));
         } else if (type === "bytes") {
-          resolve7(chunksConcat(body, length));
+          resolve8(chunksConcat(body, length));
         }
         consumeFinish(consume2);
       } catch (err) {
@@ -79215,9 +79224,9 @@ var require_api_request = __commonJS({
     };
     function request(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve8, reject) => {
           request.call(this, opts, (err, data2) => {
-            return err ? reject(err) : resolve7(data2);
+            return err ? reject(err) : resolve8(data2);
           });
         });
       }
@@ -79437,9 +79446,9 @@ var require_api_stream = __commonJS({
     };
     function stream(opts, factory, callback) {
       if (callback === void 0) {
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve8, reject) => {
           stream.call(this, opts, factory, (err, data2) => {
-            return err ? reject(err) : resolve7(data2);
+            return err ? reject(err) : resolve8(data2);
           });
         });
       }
@@ -79742,9 +79751,9 @@ var require_api_upgrade = __commonJS({
     };
     function upgrade(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve8, reject) => {
           upgrade.call(this, opts, (err, data2) => {
-            return err ? reject(err) : resolve7(data2);
+            return err ? reject(err) : resolve8(data2);
           });
         });
       }
@@ -79841,9 +79850,9 @@ var require_api_connect = __commonJS({
     };
     function connect(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve8, reject) => {
           connect.call(this, opts, (err, data2) => {
-            return err ? reject(err) : resolve7(data2);
+            return err ? reject(err) : resolve8(data2);
           });
         });
       }
@@ -81179,7 +81188,7 @@ var require_snapshot_recorder = __commonJS({
   "../../node_modules/.pnpm/undici@7.24.8/node_modules/undici/lib/mock/snapshot-recorder.js"(exports2, module2) {
     "use strict";
     var { writeFile: writeFile4, readFile: readFile4, mkdir: mkdir2 } = __require("node:fs/promises");
-    var { dirname: dirname8, resolve: resolve7 } = __require("node:path");
+    var { dirname: dirname8, resolve: resolve8 } = __require("node:path");
     var { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = __require("node:timers");
     var { InvalidArgumentError: InvalidArgumentError2, UndiciError } = require_errors3();
     var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -81387,7 +81396,7 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError2("Snapshot path is required");
         }
         try {
-          const data2 = await readFile4(resolve7(path46), "utf8");
+          const data2 = await readFile4(resolve8(path46), "utf8");
           const parsed = JSON.parse(data2);
           if (Array.isArray(parsed)) {
             this.#snapshots.clear();
@@ -81416,7 +81425,7 @@ var require_snapshot_recorder = __commonJS({
         if (!path46) {
           throw new InvalidArgumentError2("Snapshot path is required");
         }
-        const resolvedPath = resolve7(path46);
+        const resolvedPath = resolve8(path46);
         await mkdir2(dirname8(resolvedPath), { recursive: true });
         const data2 = Array.from(this.#snapshots.entries()).map(([hash2, snapshot]) => ({
           hash: hash2,
@@ -88396,7 +88405,7 @@ var require_fetch = __commonJS({
         const agent = fetchParams.controller.dispatcher;
         const path46 = url2.pathname + url2.search;
         const hasTrailingQuestionMark = url2.search.length === 0 && url2.href[url2.href.length - url2.hash.length - 1] === "?";
-        return new Promise((resolve7, reject) => agent.dispatch(
+        return new Promise((resolve8, reject) => agent.dispatch(
           {
             path: hasTrailingQuestionMark ? `${path46}?` : path46,
             origin: url2.origin,
@@ -88484,7 +88493,7 @@ var require_fetch = __commonJS({
                 }
               }
               const onError = this.onError.bind(this);
-              resolve7({
+              resolve8({
                 status,
                 statusText,
                 headersList,
@@ -88537,7 +88546,7 @@ var require_fetch = __commonJS({
                   headersList.append(headerName, String(value), true);
                 }
               }
-              resolve7({
+              resolve8({
                 status,
                 statusText: STATUS_CODES[status],
                 headersList,
@@ -88561,7 +88570,7 @@ var require_fetch = __commonJS({
                   headersList.append(nameStr, value.toString("latin1"), true);
                 }
               }
-              resolve7({
+              resolve8({
                 status,
                 statusText: STATUS_CODES[status],
                 headersList,
@@ -96276,16 +96285,16 @@ function pickSurfaces(opts) {
   return selected.length > 0 ? selected : void 0;
 }
 function withSoftTimeout(p2, ms) {
-  return new Promise((resolve7) => {
-    const t2 = setTimeout(() => resolve7({ kind: "timeout" }), ms);
+  return new Promise((resolve8) => {
+    const t2 = setTimeout(() => resolve8({ kind: "timeout" }), ms);
     p2.then(
       (value) => {
         clearTimeout(t2);
-        resolve7({ kind: "ok", value });
+        resolve8({ kind: "ok", value });
       },
       (error45) => {
         clearTimeout(t2);
-        resolve7({ kind: "error", error: error45 });
+        resolve8({ kind: "error", error: error45 });
       }
     );
   });
@@ -98169,11 +98178,11 @@ function defaultConsentIO() {
 __name(defaultConsentIO, "defaultConsentIO");
 async function readLine(prompt) {
   const readline = await import("node:readline");
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     rl.question(prompt, (answer) => {
       rl.close();
-      resolve7(answer);
+      resolve8(answer);
     });
   });
 }
@@ -101170,6 +101179,112 @@ function normalizeFimoLocale(locale) {
 }
 __name(normalizeFimoLocale, "normalizeFimoLocale");
 
+// src/scripts/validate-schemas.ts
+init_esm();
+import { existsSync as existsSync7, readFileSync as readFileSync7, readdirSync as readdirSync4 } from "node:fs";
+import { basename as basename2, join as join9, resolve as resolve6 } from "node:path";
+var SCHEMAS_REL2 = "src/schemas";
+var FIELD_TYPES = new Set(FieldTypeSchema.options);
+var RESERVED_FIELD_NAMES = new Set(RESERVED_CONTENT_FIELD_NAMES);
+function validateSchemas(options = {}) {
+  const cwd = resolve6(options.cwd ?? process.cwd());
+  const schemasDir = join9(cwd, SCHEMAS_REL2);
+  if (!existsSync7(schemasDir)) {
+    return { errors: [], schemasChecked: 0 };
+  }
+  const files = readdirSync4(schemasDir).filter((f) => f.endsWith(".json")).sort();
+  const errors2 = [];
+  for (const fileName of files) {
+    const file2 = join9(SCHEMAS_REL2, fileName);
+    errors2.push(...validateSchemaFile(join9(schemasDir, fileName), file2));
+  }
+  return { errors: errors2, schemasChecked: files.length };
+}
+__name(validateSchemas, "validateSchemas");
+function validateSchemaFile(absolutePath, file2) {
+  let schema;
+  try {
+    schema = JSON.parse(readFileSync7(absolutePath, "utf-8"));
+  } catch (error45) {
+    return [
+      {
+        rule: "schemas/parse",
+        message: `Invalid JSON: ${error45 instanceof Error ? error45.message : String(error45)}`,
+        file: file2
+      }
+    ];
+  }
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+    return [{ rule: "schemas/shape", message: "Schema must be a JSON object.", file: file2 }];
+  }
+  const errors2 = [];
+  const { uid, name, fields } = schema;
+  const expectedUid = basename2(file2, ".json");
+  if (typeof uid !== "string" || uid.length === 0) {
+    errors2.push({
+      rule: "schemas/uid",
+      message: `Missing "uid". Set it to the file name: "${expectedUid}".`,
+      file: file2
+    });
+  } else if (uid !== expectedUid) {
+    errors2.push({
+      rule: "schemas/uid",
+      message: `"uid" is "${uid}" but the file is ${expectedUid}.json \u2014 they must match.`,
+      file: file2
+    });
+  }
+  if (typeof name !== "string" || name.length === 0) {
+    errors2.push({
+      rule: "schemas/name",
+      message: 'Missing "name" (the human-readable label).',
+      file: file2
+    });
+  }
+  if (typeof fields !== "object" || fields === null || Array.isArray(fields)) {
+    errors2.push({
+      rule: "schemas/fields",
+      message: 'Missing "fields" object.',
+      file: file2
+    });
+    return errors2;
+  }
+  for (const [fieldName, definition] of Object.entries(fields)) {
+    if (RESERVED_FIELD_NAMES.has(fieldName)) {
+      errors2.push({
+        rule: "schemas/reserved-field",
+        message: `Field "${fieldName}" is reserved entry metadata \u2014 the platform manages it automatically. Remove it from the schema${fieldName === "slug" ? " (set slug inside entry data on create instead)" : ""}.`,
+        file: file2
+      });
+      continue;
+    }
+    if (typeof definition !== "object" || definition === null || Array.isArray(definition)) {
+      errors2.push({
+        rule: "schemas/field-shape",
+        message: `Field "${fieldName}" must be an object like { "type": "string" }.`,
+        file: file2
+      });
+      continue;
+    }
+    const { type } = definition;
+    if (typeof type !== "string" || !FIELD_TYPES.has(type)) {
+      errors2.push({
+        rule: "schemas/field-type",
+        message: `Field "${fieldName}" has unsupported type "${String(type)}". Allowed: ${[...FIELD_TYPES].join(", ")}.`,
+        file: file2
+      });
+    }
+    if ("i18n" in definition) {
+      errors2.push({
+        rule: "schemas/field-i18n",
+        message: `Field "${fieldName}": field-level locale settings ("i18n") are not supported.`,
+        file: file2
+      });
+    }
+  }
+  return errors2;
+}
+__name(validateSchemaFile, "validateSchemaFile");
+
 // src/cli/commands/validate.ts
 init_api();
 init_config2();
@@ -101314,8 +101429,8 @@ init_project();
 
 // src/cli/commands/scripts.ts
 init_dist();
-import { existsSync as existsSync8, readFileSync as readFileSync8, readdirSync as readdirSync5, statSync as statSync3 } from "node:fs";
-import { join as join10, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync9, readFileSync as readFileSync9, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
+import { join as join11, resolve as resolve7 } from "node:path";
 
 // src/scripts/export-static.ts
 import fs23 from "node:fs/promises";
@@ -101357,8 +101472,8 @@ async function exportStatic(options = {}) {
 __name(exportStatic, "exportStatic");
 
 // src/scripts/lint-translation-keys.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync8, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
+import { join as join10 } from "path";
 import { parseSync as parseSync2 } from "oxc-parser";
 var SRC_DIR = "src";
 function getLineAndColumn(code2, offset) {
@@ -101452,9 +101567,9 @@ function lintTranslationKeys(filePath, code2) {
 __name(lintTranslationKeys, "lintTranslationKeys");
 function findReactFiles2(dir) {
   const files = [];
-  if (!existsSync7(dir)) return files;
-  for (const entry of readdirSync4(dir)) {
-    const fullPath = join9(dir, entry);
+  if (!existsSync8(dir)) return files;
+  for (const entry of readdirSync5(dir)) {
+    const fullPath = join10(dir, entry);
     const stat2 = statSync2(fullPath);
     if (stat2.isDirectory()) {
       if (entry === "ui" || entry === "node_modules" || entry === "fimo") continue;
@@ -101468,10 +101583,10 @@ function findReactFiles2(dir) {
 __name(findReactFiles2, "findReactFiles");
 var isStandalone = process.argv[1]?.includes("lint-translation-keys");
 if (isStandalone) {
-  const reactFiles = [...findReactFiles2(join9(SRC_DIR, "components")), ...findReactFiles2(join9(SRC_DIR, "pages"))];
+  const reactFiles = [...findReactFiles2(join10(SRC_DIR, "components")), ...findReactFiles2(join10(SRC_DIR, "pages"))];
   const errors2 = [];
   for (const file2 of reactFiles) {
-    const code2 = readFileSync7(file2, "utf-8");
+    const code2 = readFileSync8(file2, "utf-8");
     errors2.push(...lintTranslationKeys(file2, code2));
   }
   if (errors2.length > 0) {
@@ -101696,7 +101811,7 @@ __name(resolveRoutes, "resolveRoutes");
 init_sync_forms();
 init_sync_schemas();
 function resolveCwd(options) {
-  return options.cwd ? resolve6(options.cwd) : process.cwd();
+  return options.cwd ? resolve7(options.cwd) : process.cwd();
 }
 __name(resolveCwd, "resolveCwd");
 function renderPrettyJson4(data2) {
@@ -101767,7 +101882,7 @@ function resolveRoutesCommand(changedFiles, options) {
 }
 __name(resolveRoutesCommand, "resolveRoutesCommand");
 function lintProject(opts) {
-  const files = opts.targetPath ? [resolve6(opts.cwd, opts.targetPath)] : collectFiles2(resolve6(opts.cwd, "src"));
+  const files = opts.targetPath ? [resolve7(opts.cwd, opts.targetPath)] : collectFiles2(resolve7(opts.cwd, "src"));
   const errors2 = [];
   let filesChecked = 0;
   for (const file2 of files) {
@@ -101775,7 +101890,7 @@ function lintProject(opts) {
       continue;
     }
     try {
-      const code2 = readFileSync8(file2, "utf-8");
+      const code2 = readFileSync9(file2, "utf-8");
       errors2.push(...lintTranslationKeys(file2, code2));
       filesChecked++;
     } catch {
@@ -101794,15 +101909,15 @@ function lintCommand(targetPath, options) {
 }
 __name(lintCommand, "lintCommand");
 function collectFiles2(root2) {
-  if (!existsSync8(root2)) {
+  if (!existsSync9(root2)) {
     return [];
   }
   const results = [];
-  for (const name of readdirSync5(root2)) {
+  for (const name of readdirSync6(root2)) {
     if (name === "node_modules" || name === "dist" || name === ".git") {
       continue;
     }
-    const full = join10(root2, name);
+    const full = join11(root2, name);
     if (statSync3(full).isDirectory()) {
       results.push(...collectFiles2(full));
     } else {
@@ -101855,10 +101970,11 @@ async function runValidate(opts) {
 __name(runValidate, "runValidate");
 async function runChecksPhase(opts) {
   const { cwd } = opts;
-  const [lintResult, routeResult, agentsResult] = await Promise.allSettled([
+  const [lintResult, routeResult, agentsResult, schemasResult] = await Promise.allSettled([
     Promise.resolve().then(() => lintProject({ cwd })),
     Promise.resolve().then(() => runRouteMetadataCheck({ cwd })),
-    Promise.resolve().then(() => runAgentsCheck({ cwd }))
+    Promise.resolve().then(() => runAgentsCheck({ cwd })),
+    Promise.resolve().then(() => validateSchemas({ cwd }))
   ]);
   const errors2 = [];
   const stats = {};
@@ -101894,6 +102010,14 @@ async function runChecksPhase(opts) {
   } else {
     errors2.push(infraErrorFromException("agents", agentsResult.reason));
   }
+  if (schemasResult.status === "fulfilled") {
+    stats.schemasChecked = schemasResult.value.schemasChecked;
+    for (const err of schemasResult.value.errors) {
+      errors2.push(authorError({ rule: err.rule, message: err.message, file: err.file }));
+    }
+  } else {
+    errors2.push(infraErrorFromException("schemas", schemasResult.reason));
+  }
   return {
     name: "Checks",
     ok: errors2.length === 0,
@@ -103886,14 +104010,14 @@ var baseOpen = /* @__PURE__ */ __name(async (options) => {
   }
   const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve8, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode > 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve7(subprocess);
+        resolve8(subprocess);
       });
     });
   }
@@ -104110,7 +104234,7 @@ async function pollUntilVerified(api, projectId, initial, timeoutMs, organizatio
       sp.fail(`SSL validation failed for ${current.hostname}.`);
       return current;
     }
-    await new Promise((resolve7) => setTimeout(resolve7, 5e3));
+    await new Promise((resolve8) => setTimeout(resolve8, 5e3));
     try {
       current = await api.refreshProjectDomain(projectId, initial.id);
       sp.update(`Waiting for ${current.hostname} (SSL: ${current.ssl.status})`);
@@ -104715,7 +104839,7 @@ async function pollPurchasePayment(api, organizationId, initial, timeoutMs) {
       sp.fail(`${current.status === "payment_failed" ? "Payment" : "Registration"} failed for ${current.domain}.`);
       return current;
     }
-    await new Promise((resolve7) => setTimeout(resolve7, 5e3));
+    await new Promise((resolve8) => setTimeout(resolve8, 5e3));
     try {
       current = await api.refreshRegisteredDomainPayment(organizationId, current.id);
       sp.update(`Waiting (status: ${current.status})`);
@@ -106953,7 +107077,7 @@ async function loginCommand() {
 }
 __name(loginCommand, "loginCommand");
 async function startCallbackServer() {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const server = createHttpServer();
     server.on("error", reject);
     server.listen(0, "127.0.0.1", () => {
@@ -106962,13 +107086,13 @@ async function startCallbackServer() {
         reject(new Error("Failed to bind callback server"));
         return;
       }
-      resolve7({ server, port: address.port });
+      resolve8({ server, port: address.port });
     });
   });
 }
 __name(startCallbackServer, "startCallbackServer");
 function waitForCallback(server, timeoutMs) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const timeout = setTimeout(() => {
       cleanup();
       reject(new Error("Timed out waiting for browser callback"));
@@ -106991,7 +107115,7 @@ function waitForCallback(server, timeoutMs) {
       }
       respond(res, 200, renderSignedInPage(), "text/html");
       cleanup();
-      resolve7({ token, state });
+      resolve8({ token, state });
     }, "handler");
     server.on("request", handler);
     function cleanup() {
@@ -107149,7 +107273,7 @@ init_api();
 init_auth_errors();
 init_color();
 import { execSync, spawnSync as spawnSync4 } from "node:child_process";
-import { mkdtempSync, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
+import { mkdtempSync, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import path37 from "node:path";
 
@@ -107554,7 +107678,7 @@ function openEditorForPick(conflict) {
   const seed = conflict.childValue !== void 0 ? JSON.stringify(conflict.childValue, null, 2) : '// Replace this comment with the resolved value as JSON\n""';
   writeFileSync6(file2, seed, "utf8");
   spawnSync4(editor, [file2], { stdio: "inherit" });
-  const raw = readFileSync9(file2, "utf8").trim();
+  const raw = readFileSync10(file2, "utf8").trim();
   if (raw === "" || raw === seed.trim()) {
     return null;
   }
@@ -108630,6 +108754,7 @@ __name(deleteCommand, "deleteCommand");
 init_dist();
 import fs41 from "node:fs";
 import path44 from "node:path";
+init_api();
 init_project_context();
 init_project();
 function toApiShape(schema) {
@@ -108671,13 +108796,17 @@ async function schemaPushCommand(typeName, options, cmd) {
     if (!fs41.existsSync(filePath)) {
       throw new Error(`Schema file not found: ${filePath}`);
     }
+    const issues = validateSchemaFile(filePath, path44.join("src/schemas", file2));
+    if (issues.length > 0) {
+      throw new Error(issues.map((issue2) => `${issue2.file}: ${issue2.message}`).join("\n"));
+    }
     const schema = JSON.parse(fs41.readFileSync(filePath, "utf-8"));
     const contentType = toApiShape(schema);
     try {
       const result = await api.createSchema(ctx.projectId, contentType);
       results.push(result);
     } catch (error45) {
-      if (error45 instanceof Error && error45.message.includes("400")) {
+      if (error45 instanceof ApiRequestError && error45.status === 400 && error45.detail === "Content type already exists") {
         const result = await api.updateSchema(ctx.projectId, contentType.name, contentType);
         results.push(result);
       } else {

package/dist/scripts/validate-schemas.d.ts

@@ -0,0 +1,13 @@
+export interface SchemaFileError {
+    rule: string;
+    message: string;
+    file: string;
+}
+export interface ValidateSchemasResult {
+    errors: SchemaFileError[];
+    schemasChecked: number;
+}
+export declare function validateSchemas(options?: {
+    cwd?: string;
+}): ValidateSchemasResult;
+export declare function validateSchemaFile(absolutePath: string, file: string): SchemaFileError[];

package/dist/scripts/validate-schemas.js

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { FieldTypeSchema, RESERVED_CONTENT_FIELD_NAMES } from '@fimo/api-contracts';
+/**
+ * Validate `src/schemas/*.json` locally against the same rules the API's
+ * schema validator enforces (field types, reserved field names, required
+ * uid/name). Catching these in `fimo validate` surfaces the real problem
+ * before a `schemas push` can fail with a less direct server error.
+ */
+const SCHEMAS_REL = 'src/schemas';
+const FIELD_TYPES = new Set(FieldTypeSchema.options);
+const RESERVED_FIELD_NAMES = new Set(RESERVED_CONTENT_FIELD_NAMES);
+export function validateSchemas(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const schemasDir = join(cwd, SCHEMAS_REL);
+    if (!existsSync(schemasDir)) {
+        return { errors: [], schemasChecked: 0 };
+    }
+    const files = readdirSync(schemasDir)
+        .filter((f) => f.endsWith('.json'))
+        .sort();
+    const errors = [];
+    for (const fileName of files) {
+        const file = join(SCHEMAS_REL, fileName);
+        errors.push(...validateSchemaFile(join(schemasDir, fileName), file));
+    }
+    return { errors, schemasChecked: files.length };
+}
+export function validateSchemaFile(absolutePath, file) {
+    let schema;
+    try {
+        schema = JSON.parse(readFileSync(absolutePath, 'utf-8'));
+    }
+    catch (error) {
+        return [
+            {
+                rule: 'schemas/parse',
+                message: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
+                file,
+            },
+        ];
+    }
+    if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) {
+        return [{ rule: 'schemas/shape', message: 'Schema must be a JSON object.', file }];
+    }
+    const errors = [];
+    const { uid, name, fields } = schema;
+    const expectedUid = basename(file, '.json');
+    if (typeof uid !== 'string' || uid.length === 0) {
+        errors.push({
+            rule: 'schemas/uid',
+            message: `Missing "uid". Set it to the file name: "${expectedUid}".`,
+            file,
+        });
+    }
+    else if (uid !== expectedUid) {
+        errors.push({
+            rule: 'schemas/uid',
+            message: `"uid" is "${uid}" but the file is ${expectedUid}.json — they must match.`,
+            file,
+        });
+    }
+    if (typeof name !== 'string' || name.length === 0) {
+        errors.push({
+            rule: 'schemas/name',
+            message: 'Missing "name" (the human-readable label).',
+            file,
+        });
+    }
+    if (typeof fields !== 'object' || fields === null || Array.isArray(fields)) {
+        errors.push({
+            rule: 'schemas/fields',
+            message: 'Missing "fields" object.',
+            file,
+        });
+        return errors;
+    }
+    for (const [fieldName, definition] of Object.entries(fields)) {
+        if (RESERVED_FIELD_NAMES.has(fieldName)) {
+            errors.push({
+                rule: 'schemas/reserved-field',
+                message: `Field "${fieldName}" is reserved entry metadata — the platform manages it automatically. ` +
+                    `Remove it from the schema${fieldName === 'slug' ? ' (set slug inside entry data on create instead)' : ''}.`,
+                file,
+            });
+            continue;
+        }
+        if (typeof definition !== 'object' || definition === null || Array.isArray(definition)) {
+            errors.push({
+                rule: 'schemas/field-shape',
+                message: `Field "${fieldName}" must be an object like { "type": "string" }.`,
+                file,
+            });
+            continue;
+        }
+        const { type } = definition;
+        if (typeof type !== 'string' || !FIELD_TYPES.has(type)) {
+            errors.push({
+                rule: 'schemas/field-type',
+                message: `Field "${fieldName}" has unsupported type "${String(type)}". Allowed: ${[...FIELD_TYPES].join(', ')}.`,
+                file,
+            });
+        }
+        if ('i18n' in definition) {
+            errors.push({
+                rule: 'schemas/field-i18n',
+                message: `Field "${fieldName}": field-level locale settings ("i18n") are not supported.`,
+                file,
+            });
+        }
+    }
+    return errors;
+}

package/dist/scripts/validate-schemas.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/validate-schemas.test.js

@@ -0,0 +1,132 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { validateSchemas } from './validate-schemas';
+describe('validateSchemas', () => {
+    let scratch = null;
+    afterEach(() => {
+        if (scratch) {
+            rmSync(scratch, { recursive: true, force: true });
+            scratch = null;
+        }
+    });
+    function writeProject(schemas) {
+        scratch = mkdtempSync(join(tmpdir(), 'validate-schemas-'));
+        mkdirSync(join(scratch, 'src/schemas'), { recursive: true });
+        for (const [fileName, schema] of Object.entries(schemas)) {
+            writeFileSync(join(scratch, 'src/schemas', fileName), typeof schema === 'string' ? schema : JSON.stringify(schema, null, 2));
+        }
+        return scratch;
+    }
+    it('accepts a valid schema', () => {
+        const cwd = writeProject({
+            'BlogPost.json': {
+                uid: 'BlogPost',
+                name: 'Blog Posts',
+                fields: {
+                    title: { type: 'string' },
+                    body: { type: 'richtext' },
+                    coverImage: { type: 'media' },
+                    featured: { type: 'boolean' },
+                },
+            },
+        });
+        expect(validateSchemas({ cwd })).toEqual({ errors: [], schemasChecked: 1 });
+    });
+    it('returns no errors when the schemas directory does not exist', () => {
+        scratch = mkdtempSync(join(tmpdir(), 'validate-schemas-'));
+        expect(validateSchemas({ cwd: scratch })).toEqual({ errors: [], schemasChecked: 0 });
+    });
+    it('rejects reserved field names like slug', () => {
+        const cwd = writeProject({
+            'TeamMember.json': {
+                uid: 'TeamMember',
+                name: 'Team Members',
+                fields: {
+                    name: { type: 'string' },
+                    slug: { type: 'string' },
+                },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/reserved-field', file: 'src/schemas/TeamMember.json' });
+        expect(errors[0].message).toContain('"slug" is reserved');
+        expect(errors[0].message).toContain('entry data');
+    });
+    it('rejects every reserved metadata name', () => {
+        const cwd = writeProject({
+            'Bad.json': {
+                uid: 'Bad',
+                name: 'Bad',
+                fields: Object.fromEntries(['id', 'documentId', 'slug', 'locale', 'createdAt', 'updatedAt', '__fimo'].map((name) => [
+                    name,
+                    { type: 'string' },
+                ])),
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(7);
+        expect(errors.every((err) => err.rule === 'schemas/reserved-field')).toBe(true);
+    });
+    it('rejects unsupported field types', () => {
+        const cwd = writeProject({
+            'Product.json': {
+                uid: 'Product',
+                name: 'Products',
+                fields: { price: { type: 'decimal' } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/field-type' });
+        expect(errors[0].message).toContain('"decimal"');
+        expect(errors[0].message).toContain('string, richtext, media');
+    });
+    it('rejects field-level i18n settings', () => {
+        const cwd = writeProject({
+            'Page.json': {
+                uid: 'Page',
+                name: 'Pages',
+                fields: { title: { type: 'string', i18n: true } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/field-i18n' });
+    });
+    it('rejects a uid that does not match the file name', () => {
+        const cwd = writeProject({
+            'TeamMember.json': {
+                uid: 'Member',
+                name: 'Team Members',
+                fields: { name: { type: 'string' } },
+            },
+        });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/uid' });
+    });
+    it('rejects missing uid, name, and fields', () => {
+        const cwd = writeProject({ 'Empty.json': {} });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors.map((err) => err.rule)).toEqual(['schemas/uid', 'schemas/name', 'schemas/fields']);
+    });
+    it('reports invalid JSON', () => {
+        const cwd = writeProject({ 'Broken.json': '{ not json' });
+        const { errors } = validateSchemas({ cwd });
+        expect(errors).toHaveLength(1);
+        expect(errors[0]).toMatchObject({ rule: 'schemas/parse' });
+    });
+    it('validates multiple files and counts them', () => {
+        const cwd = writeProject({
+            'Good.json': { uid: 'Good', name: 'Good', fields: { title: { type: 'string' } } },
+            'Bad.json': { uid: 'Bad', name: 'Bad', fields: { slug: { type: 'string' } } },
+        });
+        const result = validateSchemas({ cwd });
+        expect(result.schemasChecked).toBe(2);
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0].file).toBe('src/schemas/Bad.json');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fimo",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Fimo CLI - create, deploy, and manage Fimo projects",
   "bin": {
     "fimo": "dist/cli/index.js"

package/templates/react-router/package.json

@@ -21,7 +21,7 @@
     "cmdk": "^1.1.1",
     "date-fns": "^4.1.0",
     "embla-carousel-react": "^8.6.0",
-    "fimo": "0.3.1",
+    "fimo": "0.3.2",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "lucide-react": "^0.577.0",