@cardinali-studio/adminkit 1.0.0 → 2.1.0-rc.0

package/dist/app/site.d.ts

@@ -1,5 +1,21 @@
 import type * as z from "zod";
 export type Shape = Record<string, z.ZodType>;
+/** Contratto di UNA tipologia di pagina. Il tipo sceglie la forma prima che un file venga
+ * letto, validato o riscritto: non esiste più uno schema che contenga i campi di tutte le
+ * pagine del sito. */
+export interface PageTypeConfig {
+    label: string;
+    shape: Shape;
+    object: z.ZodType;
+    payload: z.ZodType;
+    hasBody: boolean;
+}
+/** Lingue dei contenuti, assenti nei siti monolingui. I codici sono quelli dei sibling Hugo
+ * (`index.md`, `index.en.md`): la lingua predefinita non porta alcun suffisso. */
+export interface LanguagesConfig {
+    default: string;
+    available: readonly string[];
+}
 export interface SiteAdminConfig {
     /** Il nome mostrato in cima al rail, e il ripiego del titolo nell'anteprima SEO. */
     name: string;
@@ -16,14 +32,14 @@ export interface SiteAdminConfig {
         name: string;
         email: string;
     };
-    /** Forma del front matter di una pagina della collezione. */
-    page: Shape;
+    /** Forme delle pagine della collezione, indicizzate dal loro `type` nel front matter. */
+    pages: Record<string, PageTypeConfig>;
+    /** Dichiararla abilita il contenuto bilingue; assente significa sito monolingue. */
+    languages?: LanguagesConfig;
     /** Forma del singleton home: i suoi `group` diventano le voci della seconda colonna. */
     home: Shape;
     /** Peso di ordinamento di una pagina data la sua posizione nell'elenco. */
     positionWeight: (item: Record<string, unknown>, index: number, all: Record<string, unknown>[]) => number;
-    /** Quali tipi di pagina hanno un corpo markdown oltre al front matter. */
-    hasBody: (type: unknown) => boolean;
     /**
      * Le funzioni aggiuntive accese su questo sito. Ciò che non è dichiarato è SPENTO: un
      * interruttore dimenticato deve dare una funzione assente, non una accesa per sbaglio.
@@ -35,3 +51,4 @@ export interface SiteAdminConfig {
 /** Chiamata da `mountAdmin` prima del primo render. */
 export declare function setSiteConfig(config: SiteAdminConfig): void;
 export declare function site(): SiteAdminConfig;
+export declare function pageType(type: unknown): PageTypeConfig | null;

package/dist/app/site.js

@@ -16,3 +16,6 @@ export function site() {
     }
     return current;
 }
+export function pageType(type) {
+    return site().pages[String(type ?? "")] ?? null;
+}

package/dist/form/SchemaForm.d.ts

@@ -17,5 +17,7 @@ export interface SchemaFormProps {
     }) => Promise<AssetFile[] | null>;
     /** Campi da non mostrare, anche se dichiarati (es. quelli già gestiti dall'elenco). */
     omit?: readonly string[];
+    /** Vero nella lingua secondaria: i campi senza il marchio schema restano visibili ma bloccati. */
+    translationReadOnly?: boolean;
 }
-export declare function SchemaForm({ shape, value, onChange, pickMedia, pickMediaFiles, omit }: SchemaFormProps): import("react").JSX.Element;
+export declare function SchemaForm({ shape, value, onChange, pickMedia, pickMediaFiles, omit, translationReadOnly }: SchemaFormProps): import("react").JSX.Element;

package/dist/form/SchemaForm.js

@@ -9,6 +9,7 @@ import { useMemo } from "react";
 import { useForm, Controller } from "react-hook-form";
 import * as z from "zod";
 import { ui } from "../registries.js";
+import { isTranslatable } from "../i18n.js";
 import { fieldFor } from "./registry.js";
 import "./fields/index.js"; // registra gli otto widget
 /* Resolver per React Hook Form scritto a mano invece di usare @hookform/resolvers: quel
@@ -29,7 +30,7 @@ export function zodResolver(schema) {
         return { values: {}, errors: errors };
     };
 }
-export function SchemaForm({ shape, value, onChange, pickMedia, pickMediaFiles, omit = [] }) {
+export function SchemaForm({ shape, value, onChange, pickMedia, pickMediaFiles, omit = [], translationReadOnly = false }) {
     const object = useMemo(() => z.object(shape), [shape]);
     const { control, formState } = useForm({
         values: value,
@@ -56,12 +57,17 @@ export function SchemaForm({ shape, value, onChange, pickMedia, pickMediaFiles,
     return (_jsx("div", { className: "ak-form", children: groups.map((g) => (_jsxs("fieldset", { className: "ak-group", children: [g.name && _jsx("legend", { className: "ak-legend", children: g.name }), g.fields.map((name) => {
                     const meta = ui.get(shape[name]);
                     const Field = fieldFor(meta.widget);
-                    return (_jsx(Controller, { name: name, control: control, render: ({ field }) => (_jsx(Field, { name: name, 
-                            /* `schema` serve a `objectList`, l'unico widget che deve scendere nei figli.
-                               Passarlo a tutti costa nulla e evita un canale a parte per un caso solo. */
-                            meta: { ...meta, schema: shape[name] }, value: field.value, error: formState.errors?.[name]?.message, pickMedia: pickMedia, pickMediaFiles: pickMediaFiles, onChange: (v) => {
-                                field.onChange(v);
-                                onChange({ ...value, [name]: v });
-                            } })) }, name));
+                    const nested = meta.widget === "objectList";
+                    const inherited = translationReadOnly && !isTranslatable(shape[name]);
+                    return (_jsx(Controller, { name: name, control: control, render: ({ field }) => {
+                            const control = (_jsx(Field, { name: name, 
+                                /* `schema` serve a `objectList`, l'unico widget che deve scendere nei figli.
+                                   Passarlo a tutti costa nulla e evita un canale a parte per un caso solo. */
+                                meta: { ...meta, schema: shape[name] }, value: field.value, error: formState.errors?.[name]?.message, pickMedia: pickMedia, pickMediaFiles: pickMediaFiles, translationReadOnly: translationReadOnly, onChange: (v) => {
+                                    field.onChange(v);
+                                    onChange({ ...value, [name]: v });
+                                } }));
+                            return nested ? control : _jsx("fieldset", { disabled: inherited, children: control });
+                        } }, name));
                 })] }, g.name || "_"))) }));
 }

package/dist/form/fields/objectList.js

@@ -9,6 +9,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  */
 import * as z from "zod";
 import { ui } from "../../registries.js";
+import { isTranslatable } from "../../i18n.js";
 import { registerField, fieldFor } from "../registry.js";
 /** Sotto-schema di un campo Zod, se è un oggetto: serve a scendere di un livello. */
 function shapeOf(schema) {
@@ -54,14 +55,15 @@ function blankFor(schema) {
 }
 /** Widget che rendono da soli un campo-array: qui la ricorsione non deve scendere. */
 const SELF_RENDERING_LISTS = new Set(["r2Gallery", "r2Curated", "paragraphs"]);
-function Node({ schema, value, onChange, pickMedia, pickMediaFiles, label, }) {
+function Node({ schema, value, onChange, pickMedia, pickMediaFiles, label, translationReadOnly, inheritedEditable, }) {
     const meta = ui.get(schema);
     const shape = shapeOf(schema);
     const element = elementOf(schema);
+    const editable = !translationReadOnly || inheritedEditable || isTranslatable(schema);
     // Oggetto: un riquadro con dentro i suoi campi.
     if (shape) {
         const obj = (value ?? {});
-        return (_jsx("div", { className: "ol-obj", children: Object.entries(shape).map(([k, sub]) => (_jsx(Node, { schema: sub, label: ui.get(sub)?.label ?? k, value: obj[k], pickMedia: pickMedia, pickMediaFiles: pickMediaFiles, onChange: (v) => onChange({ ...obj, [k]: v }) }, k))) }));
+        return (_jsx("div", { className: "ol-obj", children: Object.entries(shape).map(([k, sub]) => (_jsx(Node, { schema: sub, label: ui.get(sub)?.label ?? k, value: obj[k], pickMedia: pickMedia, pickMediaFiles: pickMediaFiles, translationReadOnly: translationReadOnly, inheritedEditable: editable, onChange: (v) => onChange({ ...obj, [k]: v }) }, k))) }));
     }
     /* Lista: elementi riordinabili e rimovibili — A MENO che il campo dichiari un widget che sa
      * già rendere una lista per conto suo. La ricorsione si ferma lì e disegna il widget.
@@ -82,18 +84,19 @@ function Node({ schema, value, onChange, pickMedia, pickMediaFiles, label, }) {
             next.splice(to, 0, x);
             onChange(next);
         };
-        return (_jsxs("fieldset", { className: "ol-list", children: [_jsx("legend", { className: "ak-legend", children: label ?? meta?.label }), list.map((item, i) => (_jsxs("div", { className: "ol-item", children: [_jsxs("div", { className: "ol-item-bar", children: [_jsx("span", { className: "ak-hint", children: i + 1 }), _jsx("span", { className: "ak-spacer" }), _jsx("button", { type: "button", className: "ak-icon", title: "Su", onClick: () => move(i, i - 1), children: "\u2191" }), _jsx("button", { type: "button", className: "ak-icon", title: "Gi\u00F9", onClick: () => move(i, i + 1), children: "\u2193" }), _jsx("button", { type: "button", className: "ak-icon", title: "Rimuovi", onClick: () => onChange(list.filter((_, j) => j !== i)), children: "\u2715" })] }), _jsx(Node, { schema: element, value: item, pickMedia: pickMedia, pickMediaFiles: pickMediaFiles, onChange: (v) => onChange(list.map((x, j) => (j === i ? v : x))) })] }, i))), _jsx("button", { type: "button", className: "ak-btn", onClick: () => onChange([...list, blankFor(element)]), children: "+ Aggiungi" })] }));
+        return (_jsxs("fieldset", { className: "ol-list", children: [_jsx("legend", { className: "ak-legend", children: label ?? meta?.label }), list.map((item, i) => (_jsxs("div", { className: "ol-item", children: [_jsxs("div", { className: "ol-item-bar", children: [_jsx("span", { className: "ak-hint", children: i + 1 }), _jsx("span", { className: "ak-spacer" }), _jsx("button", { type: "button", disabled: !editable, className: "ak-icon", title: "Su", onClick: () => move(i, i - 1), children: "\u2191" }), _jsx("button", { type: "button", disabled: !editable, className: "ak-icon", title: "Gi\u00F9", onClick: () => move(i, i + 1), children: "\u2193" }), _jsx("button", { type: "button", disabled: !editable, className: "ak-icon", title: "Rimuovi", onClick: () => onChange(list.filter((_, j) => j !== i)), children: "\u2715" })] }), _jsx(Node, { schema: element, value: item, pickMedia: pickMedia, pickMediaFiles: pickMediaFiles, translationReadOnly: translationReadOnly, inheritedEditable: editable, onChange: (v) => onChange(list.map((x, j) => (j === i ? v : x))) })] }, i))), _jsx("button", { type: "button", disabled: !editable, className: "ak-btn", onClick: () => onChange([...list, blankFor(element)]), children: "+ Aggiungi" })] }));
     }
     // Foglia: la disegna il widget dichiarato, come qualsiasi altro campo.
     const w = meta?.widget ?? "text";
     const Field = fieldFor(w);
-    return (_jsx(Field, { name: label ?? "", meta: { ...(meta ?? { label: label ?? "", widget: w }), label: label ?? meta?.label ?? "" }, value: value, onChange: onChange, pickMedia: pickMedia, pickMediaFiles: pickMediaFiles }));
+    const control = (_jsx(Field, { name: label ?? "", meta: { ...(meta ?? { label: label ?? "", widget: w }), label: label ?? meta?.label ?? "" }, value: value, onChange: onChange, pickMedia: pickMedia, pickMediaFiles: pickMediaFiles }));
+    return _jsx("fieldset", { disabled: !editable, children: control });
 }
 /* Il widget registrato riceve lo SCHEMA del campo attraverso `meta.schema`, che SchemaForm gli
  * passa: senza, non potrebbe sapere che forma abbiano i figli. */
-registerField("objectList", ({ meta, value, onChange, pickMedia, pickMediaFiles }) => {
+registerField("objectList", ({ meta, value, onChange, pickMedia, pickMediaFiles, translationReadOnly }) => {
     const schema = meta.schema;
     if (!schema)
         return _jsx("p", { className: "ak-error", children: "objectList senza schema: va passato da SchemaForm." });
-    return (_jsxs("fieldset", { className: "ak-group ol", children: [_jsx("legend", { className: "ak-legend", children: meta.label }), meta.hint && _jsx("p", { className: "ak-hint", children: meta.hint }), _jsx(Node, { schema: schema, value: value, onChange: onChange, pickMedia: pickMedia, pickMediaFiles: pickMediaFiles })] }));
+    return (_jsxs("fieldset", { className: "ak-group ol", children: [_jsx("legend", { className: "ak-legend", children: meta.label }), meta.hint && _jsx("p", { className: "ak-hint", children: meta.hint }), _jsx(Node, { schema: schema, value: value, onChange: onChange, pickMedia: pickMedia, pickMediaFiles: pickMediaFiles, translationReadOnly: translationReadOnly })] }));
 });

package/dist/form/registry.d.ts

@@ -6,6 +6,8 @@ export interface FieldProps {
     value: unknown;
     onChange: (v: unknown) => void;
     error?: string;
+    /** La lingua secondaria delega ai widget ricorsivi i soli campi marcati traducibili. */
+    translationReadOnly?: boolean;
     /** Aperto dai widget che scelgono media e vogliono solo il percorso (r2Image, r2Gallery). */
     pickMedia?: (opts: {
         multiple: boolean;

package/dist/functions/_shared/media-content.js

@@ -5,7 +5,7 @@
  * quando possibile, riscritti durante delete/move dei media.
  */
 import { deserializeItem, checkFidelity } from "../../index.js";
-import { site } from "../site.js";
+import { site, pageType } from "../site.js";
 import {
   getRepoSnapshot, getText, commitUpserts, GitHubConflictError,
 } from "./github.js";
@@ -36,6 +36,12 @@ function jsonSource(path, text, label) {
   return { kind: "settings", path, text, label };
 }
 
+function typeOf(md) {
+  const m = (md || "").match(/^---\n([\s\S]*?)\n---/);
+  const t = m && m[1].match(/^type:\s*(.+)$/m);
+  return t ? t[1].trim().replace(/^["']|["']$/g, "") : "";
+}
+
 /** Legge tutte le sorgenti dallo stesso commit, senza trasformare errori in file vuoti. */
 export async function readMediaSources(env) {
   const snapshot = await getRepoSnapshot(env);
@@ -61,7 +67,9 @@ export async function readMediaSources(env) {
     }
     const slug = path.split("/")[1] || "";
     const extra = { slug };
-    return frontmatterSource(path, text, pageLabel(text, path, site().page, extra), site().page, site().pageObject, extra);
+    const definition = pageType(typeOf(text));
+    if (!definition) throw new Error(`${path}: tipo pagina non gestito`);
+    return frontmatterSource(path, text, pageLabel(text, path, definition.shape, extra), definition.shape, definition.object, extra);
   });
   return { base: { commitSha: snapshot.commitSha, treeSha: snapshot.treeSha }, sources };
 }

package/dist/functions/_shared/translations.js

@@ -0,0 +1,18 @@
+/* Convenzioni Hugo per le traduzioni di una pagina: `index.md` è la lingua predefinita,
+ * `index.en.md` una sibling. Tutto ciò che non è dichiarato in site.config resta invisibile
+ * qui: non si deve mai dedurre una lingua da un file trovato per caso. */
+import { languages } from "../site.js";
+
+export function languageConfig() {
+  return languages();
+}
+
+export function pagePath(slug, language, defaultLanguage) {
+  const suffix = language === defaultLanguage ? "" : `.${language}`;
+  return `content/${slug}/index${suffix}.md`;
+}
+
+export function translatedLanguages() {
+  const config = languageConfig();
+  return config ? config.available.filter((language) => language !== config.default) : [];
+}

package/dist/functions/api/pages/get.js

@@ -3,24 +3,49 @@
  */
 import { json } from "../../_shared/assets.js";
 import { getText } from "../../_shared/github.js";
-import { splitFrontMatter, deserializeItem } from "../../../index.js";
-import { site } from "../../site.js";
+import { splitFrontMatter, deserializeItem, translationModel } from "../../../index.js";
+import { pageType } from "../../site.js";
+import { languageConfig, pagePath } from "../../_shared/translations.js";
+
+function typeOf(md) {
+  const m = (md || "").match(/^---\n([\s\S]*?)\n---/);
+  const t = m && m[1].match(/^type:\s*(.+)$/m);
+  return t ? t[1].trim().replace(/^["']|["']$/g, "") : "";
+}
 
 export async function onRequestGet({ request, env }) {
   if (!env.GITHUB_TOKEN || !env.GITHUB_REPO) return json({ ok: false, error: "backend GitHub non configurato" }, 500);
-  const slug = new URL(request.url).searchParams.get("slug") || "";
+  const url = new URL(request.url);
+  const slug = url.searchParams.get("slug") || "";
   if (!/^[a-z0-9-]+$/.test(slug)) return json({ ok: false, error: "slug non valido" }, 400);
 
-  const text = await getText(env, `content/${slug}/index.md`);
-  if (text == null) return json({ ok: false, error: "pagina non trovata" }, 404);
+  const languages = languageConfig();
+  const requested = url.searchParams.get("lang") || languages?.default || "";
+  if (languages && !languages.available.includes(requested)) return json({ ok: false, error: "lingua non dichiarata" }, 400);
+  if (!languages && url.searchParams.has("lang")) return json({ ok: false, error: "questo sito è monolingue" }, 400);
 
-  const { body: rawBody } = splitFrontMatter(text);
-  const body = (rawBody ?? text).replace(/^\n+/, "").replace(/\s+$/, "");
+  const defaultLanguage = languages?.default || "";
+  const defaultText = await getText(env, pagePath(slug, defaultLanguage, defaultLanguage));
+  if (defaultText == null) return json({ ok: false, error: "pagina non trovata" }, 404);
+  const isDefault = !languages || requested === defaultLanguage;
+  const text = isDefault ? defaultText : await getText(env, pagePath(slug, requested, defaultLanguage));
+
+  const { body: defaultRawBody } = splitFrontMatter(defaultText);
+  const defaultBody = (defaultRawBody ?? defaultText).replace(/^\n+/, "").replace(/\s+$/, "");
 
   // Il front matter lo legge lo schema, non uno scanner di righe scritto qui: prima questo
   // file aveva la sua interpretazione, diversa da quella del serializzatore, e due letture
   // dello stesso formato sono due occasioni di divergere.
-  const model = deserializeItem(text, site().page, { slug });
+  const definition = pageType(typeOf(defaultText));
+  if (!definition) return json({ ok: false, error: "tipo pagina non gestito" }, 404);
+  const defaultModel = deserializeItem(defaultText, definition.shape, { slug });
+  const model = isDefault ? defaultModel : translationModel(
+    definition.shape,
+    defaultModel,
+    text ? deserializeItem(text, definition.shape, { slug }) : {},
+  );
+  const { body: rawBody } = splitFrontMatter(text);
+  const body = ((rawBody ?? (text ?? defaultBody))).replace(/^\n+/, "").replace(/\s+$/, "");
 
-  return json({ ok: true, slug, body, page: model });
+  return json({ ok: true, slug, body, page: model, language: requested || undefined, exists: isDefault || !!text });
 }

package/dist/functions/api/pages.js

@@ -16,9 +16,10 @@
  * Sta dietro Cloudflare Access E dietro la verifica del JWT in functions/admin/_middleware.js.
  * Secret/vars: GITHUB_TOKEN (secret), GITHUB_REPO, GITHUB_BRANCH.
  */
-import { serializeItem, deserializeItem, checkFidelity } from "../../index.js";
-import { site } from "../site.js";
+import { serializeItem, deserializeItem, checkFidelity, translationModel, inheritedFieldPaths, withTranslationHeader } from "../../index.js";
+import { site, pageType } from "../site.js";
 import { getRepoSnapshot, getText, DRAFT } from "../_shared/github.js";
+import { languageConfig, pagePath, translatedLanguages } from "../_shared/translations.js";
 
 const GH = "https://api.github.com";
 
@@ -83,6 +84,8 @@ export async function onRequestGet({ env }) {
     const snapshot = await getRepoSnapshot(env);
     const blobs = snapshot.tree.filter((t) => t.type === "blob" && site().isManagedPath(t.path));
 
+    const language = languageConfig();
+    const shaByPath = new Map(snapshot.tree.filter((t) => t.type === "blob").map((t) => [t.path, t.sha]));
     const letti = await Promise.all(blobs.map(async (t) => {
       const text = await getText(env, t.path, snapshot.commitSha);
       if (text == null) return null;
@@ -90,7 +93,18 @@ export async function onRequestGet({ env }) {
       // due criteri erano scritti in due posti e coincidevano solo per caso.
       if (site().excludedTypes.includes(typeOf(text))) return null;
       const slug = t.path.split("/")[1];
-      return { slug, url: `/${slug}/`, sha: t.sha, page: deserializeItem(text, site().page, { slug }) };
+      const definition = pageType(typeOf(text));
+      if (!definition) return null;
+      const translations = language
+        ? Object.fromEntries(translatedLanguages().map((code) => {
+            const sha = shaByPath.get(pagePath(slug, code, language.default));
+            return [code, { exists: !!sha, ...(sha ? { sha } : {}) }];
+          }))
+        : undefined;
+      return {
+        slug, url: `/${slug}/`, sha: t.sha, page: deserializeItem(text, definition.shape, { slug }),
+        ...(translations ? { translations } : {}),
+      };
     }));
 
     const pages = letti.filter(Boolean)
@@ -140,7 +154,17 @@ export async function onRequestPost({ request, env, data }) {
    * risultato del parse la romperebbe in silenzio. Si valida l'oggetto e si serializza quello. */
   const problems = [];
   for (const p of pages) {
-    const r = site().pagePayload.safeParse(p);
+    const definition = pageType(p?.type);
+    if (!definition) {
+      /* Le pagine lasciate intatte viaggiano intenzionalmente come solo riferimento
+       * (`slug`, `_orig`, `_sha`, `inMenu`): il loro tipo si ricava dal file esistente più
+       * avanti, quando lo stesso giro carica il contenuto da preservare. Una pagina NUOVA,
+       * invece, non ha nessun file da cui scoprirlo e deve dichiararlo qui. */
+      if (p?.type === undefined && p?._orig) continue;
+      problems.push({ slug: typeof p?.slug === "string" ? p.slug : "?", detail: "tipo pagina non gestito" });
+      continue;
+    }
+    const r = definition.payload.safeParse(p);
     if (r.success) continue;
     const detail = r.error.issues.slice(0, 5)
       .map((i) => `${i.path.join(".") || "?"} ${i.message}`).join("; ");
@@ -184,6 +208,8 @@ async function commitPages(args, attempt = 0) {
   const managed = tree.filter((t) => site().isManagedPath(t.path));
   const existingSlugs = new Set(managed.map((t) => t.path.split("/")[1]));
   const shaOf = new Map(managed.map((t) => [t.path.split("/")[1], t.sha]));
+  const shaByPath = new Map(tree.filter((t) => t.type === "blob").map((t) => [t.path, t.sha]));
+  const language = languageConfig();
 
   /* CONTROLLO DI VERSIONE PER FILE. Il client dice da quale versione è partito (`_sha`, lo sha
    * del blob che gli ha dato l'elenco); se quel file nel frattempo è cambiato, la sua copia è
@@ -204,6 +230,17 @@ async function commitPages(args, attempt = 0) {
     const attuale = shaOf.get(sourceSlug);
     if (attuale && attuale !== p._sha) stale.push(sourceSlug);
   }
+  if (language) {
+    for (const p of pages) {
+      const sourceSlug = existingSlugs.has(p.slug) ? p.slug : (p._orig || p.slug);
+      for (const code of translatedLanguages()) {
+        const update = p?._translations?.[code];
+        if (!update?._sha) continue;
+        const current = shaByPath.get(pagePath(sourceSlug, code, language.default));
+        if (current && current !== update._sha) stale.push(`${sourceSlug}.${code}`);
+      }
+    }
+  }
   if (stale.length) {
     // Tutto o niente come gli altri rifiuti: il commit è atomico, e salvarne metà lascerebbe a
     // terra l'altra metà senza che nessuno sappia quale.
@@ -226,6 +263,7 @@ async function commitPages(args, attempt = 0) {
   const entries = [];
   const desiredSlugs = new Set();
   const rejected = [];
+  const invalidTypes = [];
 
   for (const p of pages) {
     desiredSlugs.add(p.slug);
@@ -235,12 +273,14 @@ async function commitPages(args, attempt = 0) {
     const oldMd = sourceSlug
       ? await readFile(env, repo, branch, `content/${sourceSlug}/index.md`)
       : null;
+    const definition = pageType(p.type || typeOf(oldMd));
+    if (!definition) { invalidTypes.push(p.slug); continue; }
 
     // GUARDIA DI FEDELTÀ: se non sappiamo riprodurre il file che stiamo per sovrascrivere,
     // non lo sovrascriviamo. Intercetta i costrutti che il lettore del front matter non regge
     // e trasforma una corruzione silenziosa in un rifiuto visibile.
     if (oldMd) {
-      const f = checkFidelity(oldMd, site().page, { slug: sourceSlug });
+      const f = checkFidelity(oldMd, definition.shape, { slug: sourceSlug });
       if (!f.ok) { rejected.push(sourceSlug); continue; }
     }
 
@@ -249,15 +289,64 @@ async function commitPages(args, attempt = 0) {
       mode: "100644",
       type: "blob",
       content: serializeItem(p, {
-        shape: site().page,
+        shape: definition.shape,
         oldMd,
         // Solo per i tipi che un corpo ce l'hanno: su una gallery il segnaposto sarebbe
         // testo scritto nel repo che non compare da nessuna parte (vedi hasBody).
-        placeholderBody: site().hasBody(p.type)
+        placeholderBody: definition.hasBody
           ? (m) => `Placeholder content for **${m.title || p.slug}**.`
           : undefined,
       }),
     });
+
+    /* Una lingua secondaria arriva esplicitamente dal client solo se è stata aperta o
+     * modificata. Non creare file vuoti per ogni pagina: la prima apertura di EN li mostra
+     * già come ereditati, ma il file nasce al primo salvataggio di quella lingua. */
+    if (language) {
+      for (const code of translatedLanguages()) {
+        const update = p?._translations?.[code];
+        if (!update) continue;
+        const oldTranslation = sourceSlug
+          ? await readFile(env, repo, branch, pagePath(sourceSlug, code, language.default))
+          : null;
+        if (oldTranslation) {
+          const fidelity = checkFidelity(oldTranslation, definition.shape, { slug: sourceSlug });
+          if (!fidelity.ok) { rejected.push(`${p.slug}.${code}`); continue; }
+        }
+        const candidate = update.page && typeof update.page === "object" ? update.page : update;
+        const translated = translationModel(definition.shape, p, candidate);
+        if (definition.hasBody) {
+          if (typeof update.body === "string") translated.body = update.body;
+          else if (!oldTranslation && typeof p.body === "string") translated.body = p.body;
+        }
+        const valid = definition.payload.safeParse(translated);
+        if (!valid.success) { invalidTypes.push(`${p.slug}.${code}`); continue; }
+        const content = withTranslationHeader(serializeItem(translated, {
+          shape: definition.shape,
+          oldMd: oldTranslation,
+          placeholderBody: definition.hasBody
+            ? (m) => `Placeholder content for **${m.title || p.slug}**.`
+            : undefined,
+        }), {
+          language: code,
+          defaultLanguage: language.default,
+          inherited: inheritedFieldPaths(definition.shape),
+        });
+        entries.push({ path: pagePath(p.slug, code, language.default), mode: "100644", type: "blob", content });
+      }
+    }
+  }
+
+  if (invalidTypes.length) {
+    return {
+      status: 400,
+      body: {
+        ok: false,
+        code: "invalid",
+        error: `Tipo pagina non gestito per: ${invalidTypes.join(", ")}. Non ho salvato nulla.`,
+        slugs: invalidTypes,
+      },
+    };
   }
 
   if (rejected.length) {
@@ -286,6 +375,12 @@ async function commitPages(args, attempt = 0) {
     const md = await readFile(env, repo, branch, `content/${slug}/index.md`);
     if (md && site().excludedTypes.includes(typeOf(md))) { skipped.push(slug); continue; }
     entries.push({ path: `content/${slug}/index.md`, mode: "100644", type: "blob", sha: null });
+    if (language) {
+      for (const code of translatedLanguages()) {
+        const path = pagePath(slug, code, language.default);
+        if (shaByPath.has(path)) entries.push({ path, mode: "100644", type: "blob", sha: null });
+      }
+    }
   }
 
   // 5) tree, commit, ref
@@ -342,7 +437,20 @@ async function commitPages(args, attempt = 0) {
     const t = await gh(env, `/repos/${repo}/git/trees/${newTreeSha}?recursive=1`);
     if (t.ok) {
       for (const e of (await t.json()).tree || []) {
-        if (e.type === "blob" && site().isManagedPath(e.path)) shas[e.path.split("/")[1]] = e.sha;
+        if (e.type !== "blob") continue;
+        if (site().isManagedPath(e.path)) {
+          shas[e.path.split("/")[1]] = e.sha;
+          continue;
+        }
+        /* Le sibling non passano da isManagedPath (che seleziona il solo index.md), ma hanno
+           lo stesso controllo di versione. Rimandare anche il loro SHA evita un falso stale al
+           salvataggio successivo della stessa traduzione. */
+        if (language) {
+          for (const code of translatedLanguages()) {
+            const match = e.path.match(/^content\/([^/]+)\/index\.([a-z0-9-]+)\.md$/);
+            if (match?.[2] === code) shas[`${match[1]}.${code}`] = e.sha;
+          }
+        }
       }
     }
   } catch { /* il salvataggio è andato: senza gli sha il client ricarica, non perde niente */ }

package/dist/functions/site.js

@@ -36,3 +36,18 @@ export function site() {
 export function moduleEnabled(name) {
   return current?.modules?.[name] === true;
 }
+
+/** La stessa scelta di tipo che fa la shell. Tenerla qui evita che endpoint diversi
+ * deserializzino, validino e serializzino una pagina con forme differenti. */
+export function pageType(type) {
+  return current?.pages?.[String(type ?? "")] ?? null;
+}
+
+/** `null` lascia il sito rigorosamente monolingue. Gli endpoint non inferiscono lingue dai file:
+ * una coppia `index.en.md` non dichiarata non deve comparire né essere riscritta per caso. */
+export function languages() {
+  const config = current?.languages;
+  if (!config || typeof config.default !== "string" || !Array.isArray(config.available)) return null;
+  const available = [...new Set(config.available.filter((language) => typeof language === "string" && language))];
+  return available.includes(config.default) ? { default: config.default, available } : null;
+}

package/dist/i18n.d.ts

@@ -0,0 +1,26 @@
+import * as z from "zod";
+export type TranslationShape = Record<string, z.ZodType>;
+export interface TranslationMeta {
+    translatable: boolean;
+}
+/** Registro separato da `ui`: la scelta influenza il Worker e il codec, non solo il form. */
+export declare const i18n: z.core.$ZodRegistry<TranslationMeta, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+/** Marca un campo (anche un array o un oggetto intero) come modificabile in una traduzione. */
+export declare function translatable<T extends z.ZodType>(field: T): T;
+export declare function isTranslatable(schema: z.ZodType): boolean;
+/** Unisce una traduzione al modello predefinito senza lasciarle modificare dati ereditati.
+ *
+ * Gli array non traducibili mantengono la loro struttura predefinita; i loro elementi possono
+ * però contenere campi foglia traducibili. Se un'intera lista deve essere traducibile (titolo
+ * spezzato in righe, paragrafi, ecc.), va marcata la lista stessa, non ogni sua stringa. */
+export declare function mergeTranslation(schema: z.ZodType, defaultValue: unknown, translationValue: unknown): unknown;
+/** Modello completo della traduzione: utile sia al primo salvataggio sia a ogni risalvataggio. */
+export declare function translationModel(shape: TranslationShape, defaultModel: Record<string, unknown>, translationModel?: Record<string, unknown>): Record<string, unknown>;
+/** Percorsi dei valori che saranno sempre ricopiati dalla lingua predefinita. */
+export declare function inheritedFieldPaths(shape: TranslationShape): string[];
+/** Inserisce (o aggiorna) l'avviso che impedisce modifiche manuali ingannevoli ai dati ereditati. */
+export declare function withTranslationHeader(markdown: string, options: {
+    language: string;
+    defaultLanguage: string;
+    inherited: readonly string[];
+}): string;