@cbjk_iris/schema 0.0.0-stage → 0.0.0

package/dist/page-DxWfFiUO.mjs

@@ -0,0 +1,1035 @@
+import { i as LEAD_FIELDS, o as SECTION_ICONS } from "./constants-C4TYxqGV.mjs";
+import { z } from "zod";
+//#region src/fields.ts
+/** Mensagens padrão do zod em pt-BR, por parse ({ error: ptBRError }), sem mexer na config global. */
+const ptBRError = z.locales.ptBR().localeError;
+const slugSchema = z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, { error: "use só letras minúsculas, números e hífens (ex.: capa-iphone-15)" }).max(80, { error: "no máximo 80 caracteres" });
+const MAX_URL_LENGTH = 2048;
+/**
+* Caracteres que o navegador ou o new URL() removem ou reinterpretam, e que por isso não podem
+* aparecer em link nem em caminho: controle (C0, DEL, C1), espaço, espaços e marcas invisíveis
+* (NBSP, soft hyphen, ZWSP/ZWNJ/ZWJ, LRM/RLM, controles bidi, separadores de linha e parágrafo,
+* word joiner e os invisíveis de U+2061 a U+206F, CGJ U+034F, ALM U+061C, MVS U+180E, BOM), a barra
+* invertida (o navegador a trata como /) e os pontos unicode que viram "." no host.
+* Ex.: "/\t/evil.com" vira "//evil.com" no navegador.
+*/
+const UNSAFE_CHARS = /[\u0000-\u0020\u007f-\u00a0\u00ad\u034f\u061c\u180e\u200b-\u200f\u2028\u2029\u202a-\u202e\u2060-\u206f\ufeff\\\u3002\uff0e\uff61]/;
+/** true se o valor cru tem caractere que o navegador reinterpretaria (ver UNSAFE_CHARS). */
+function hasUnsafeChars(value) {
+	return UNSAFE_CHARS.test(value);
+}
+/**
+* Por que a URL foi recusada (ou null se passou): sem caractere inseguro no valor cru, só
+* https, sem usuário e senha, sem porta explícita, até 2048 caracteres. Com hosts, o hostname
+* precisa ser um deles ou subdomínio (host === d || host.endsWith("." + d)), comparado em
+* minúsculas depois do new URL().
+*/
+function urlProblem(value, hosts) {
+	if (hasUnsafeChars(value)) return "não pode ter espaço, caractere invisível ou de controle, nem \\";
+	if (value.length > 2048) return `no máximo ${MAX_URL_LENGTH} caracteres`;
+	if (!value.startsWith("https://")) return "precisa começar com https://";
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return "não é uma URL válida";
+	}
+	if (url.protocol !== "https:" || !url.hostname) return "precisa começar com https://";
+	if (url.username || url.password) return "não pode ter usuário e senha na URL";
+	if (url.port) return "não pode ter porta na URL";
+	if (hosts && !hosts.some((d) => url.hostname === d || url.hostname.endsWith(`.${d}`))) return "host não permitido";
+	return null;
+}
+const httpsPattern = /^https:\/\//;
+/**
+* Link https. Com `hosts`, só esses hosts e subdomínios. `message` troca a mensagem de erro
+* (uma só para qualquer falha).
+*/
+function httpsUrlWith(message, hosts) {
+	return z.string().regex(httpsPattern, { error: message ?? "precisa começar com https://" }).max(MAX_URL_LENGTH, { error: message ?? `no máximo 2048 caracteres` }).superRefine((value, ctx) => {
+		const problem = urlProblem(value, hosts);
+		if (problem && value.startsWith("https://") && value.length <= 2048) ctx.addIssue({
+			code: "custom",
+			message: message ?? problem
+		});
+	});
+}
+const httpsUrl = httpsUrlWith();
+const hasDotDot = (path) => path.split("/").includes("..");
+const ENCODED_SEPARATORS = /%(?:2e|2f|5c)/i;
+/** Caminho local seguro: começa com uma / só, sem .., sem separador codificado. */
+function isLocalPath(v) {
+	return v.startsWith("/") && !v.startsWith("//") && !hasDotDot(v) && !ENCODED_SEPARATORS.test(v);
+}
+/** Imagem: caminho em public/ (começa com /, sem // e sem ..) ou URL https. */
+const imageSrc = z.string().refine((v) => !hasUnsafeChars(v) && (isLocalPath(v) || urlProblem(v) === null), { error: "use um caminho em public/ começando com / (ex.: /products/foto.jpg) ou um link https://, sem espaço nem caractere invisível" });
+const EMAIL_RE = z.regexes.email;
+/**
+* mailto: com um endereço só e, na query, só subject e body. Recusa cc, bcc, to e outros
+* parâmetros (mandariam cópia para outro endereço) e %0d/%0a (injeção de cabeçalho).
+*/
+function isSafeMailto(v) {
+	if (!v.startsWith("mailto:") || /%0[ad]/i.test(v)) return false;
+	const [address, query, ...rest] = v.slice(7).split("?");
+	if (rest.length || !EMAIL_RE.test(address)) return false;
+	if (query === void 0) return true;
+	const keys = [...new URLSearchParams(query).keys()];
+	return keys.length > 0 && keys.every((k) => k === "subject" || k === "body");
+}
+/** Destino de link: rota do site (/sobre), âncora (#contato), https:, mailto: ou tel:. */
+const siteHref = z.string().refine((v) => !hasUnsafeChars(v) && (isLocalPath(v) || /^#[\w-]*$/.test(v) || isSafeMailto(v) || /^tel:\+?[\d()-]+$/.test(v) || urlProblem(v) === null), { error: "use uma rota (/sobre), uma âncora (#contato) ou um link https://, mailto: ou tel:, sem espaço nem caractere invisível" });
+/** Funções CSS permitidas em cssValue (cores e contas). Qualquer outra é recusada. */
+const CSS_FUNCTIONS = /* @__PURE__ */ new Set([
+	"calc",
+	"min",
+	"max",
+	"clamp",
+	"var",
+	"rgb",
+	"rgba",
+	"hsl",
+	"hsla",
+	"hwb",
+	"lab",
+	"lch",
+	"oklab",
+	"oklch",
+	"color",
+	"color-mix"
+]);
+/** Por que o valor CSS foi recusado (ou null): parênteses, funções permitidas e var(--nome). */
+function cssStructureProblem(v) {
+	if (v.length > 200) return "no máximo 200 caracteres";
+	let depth = 0;
+	for (const ch of v) {
+		if (ch === "(") depth++;
+		if (ch === ")" && --depth < 0) return "parênteses desbalanceados";
+	}
+	if (depth !== 0) return "parênteses desbalanceados";
+	for (const [, name] of v.matchAll(/(-?[a-z_][\w-]*)\s*\(/gi)) if (!CSS_FUNCTIONS.has(name.toLowerCase())) return `função ${name}() não é permitida (use calc, min, max, clamp, var, rgb, hsl, oklch, color-mix...)`;
+	for (const m of v.matchAll(/var\s*\(/gi)) if (!/^\s*--[\w-]+\s*[,)]/.test(v.slice(m.index + m[0].length))) return "var() precisa de uma variável --nome como primeiro argumento";
+	return null;
+}
+/**
+* Valor CSS que vai cru para o <style> do layout (cores, raio, tokens de forma). Estrutura
+* permitida, não lista negra: até 200 caracteres; só os caracteres A-Z a-z 0-9, espaço e
+* . , % # ( ) / + - * _ (sem colchete, que abriria um bloco que engole o resto da folha; sem
+* ; : { } < > @ aspas, barra invertida e não-ASCII); sem início ou fim de comentário;
+* parênteses balanceados; só as funções de CSS_FUNCTIONS; var() só com --nome.
+*/
+const cssValue = z.string().min(1).max(200, {
+	error: "valor CSS com no máximo 200 caracteres",
+	abort: true
+}).regex(/^[A-Za-z0-9 .,%#()/+*_-]*$/, {
+	error: "valor CSS só pode ter letras sem acento, números, espaço e . , % # ( ) / + - * _",
+	abort: true
+}).refine((v) => !/\/\*|\*\//.test(v), { error: "valor CSS não pode ter comentário" }).superRefine((v, ctx) => {
+	const problem = cssStructureProblem(v);
+	if (problem) ctx.addIssue({
+		code: "custom",
+		message: `valor CSS inválido: ${problem}`
+	});
+});
+/** Comprimento CSS simples (ex.: 320px, 20rem, 50vh). */
+const cssLength = z.string().regex(/^\d+(?:\.\d+)?(?:px|rem|em|vh|svh|dvh)$/, { error: "use um comprimento simples, ex.: 320px" });
+const LABEL_RE = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+/**
+* Sufixos de hospedagem pública e de registro de 2 níveis: como host inteiro, liberariam no
+* /_next/image as imagens de qualquer cliente desse provedor. Subdomínio específico
+* (meu-site.vercel.app, minha-loja.com.br) é aceito. Lista é dado, não contrato: PR ao arquiteto.
+*/
+const PUBLIC_SUFFIX_HOSTS = [
+	"github.io",
+	"vercel.app",
+	"netlify.app",
+	"pages.dev",
+	"workers.dev",
+	"amazonaws.com",
+	"s3.amazonaws.com",
+	"cloudfront.net",
+	"blob.core.windows.net",
+	"appspot.com",
+	"firebaseapp.com",
+	"web.app",
+	"herokuapp.com",
+	"onrender.com",
+	"fly.dev",
+	"azurewebsites.net",
+	"googleusercontent.com",
+	"storage.googleapis.com",
+	"r2.dev",
+	"ngrok.io",
+	"ngrok-free.app",
+	"trycloudflare.com",
+	"duckdns.org",
+	"no-ip.org",
+	"googleapis.com",
+	"surge.sh",
+	"glitch.me",
+	"repl.co",
+	"co.uk",
+	"org.uk",
+	"ac.uk",
+	"com.br",
+	"net.br",
+	"org.br",
+	"gov.br",
+	"com.au",
+	"net.au",
+	"co.jp",
+	"com.mx",
+	"com.ar",
+	"co.nz",
+	"co.za",
+	"com.cn",
+	"co.kr",
+	"co.in"
+];
+/**
+* Rede interna, nomes reservados e DNS curinga (resolvem para qualquer IP, inclusive privado):
+* recusados como sufixo ou host inteiro. Defesa em profundidade: a defesa principal é do Next,
+* cujo otimizador recusa IP local por padrão (images.dangerouslyAllowLocalIP: false).
+*/
+const PRIVATE_HOST_SUFFIXES = [
+	"internal",
+	"local",
+	"localhost",
+	"home.arpa",
+	"arpa",
+	"lan",
+	"corp",
+	"intranet",
+	"private",
+	"home",
+	"test",
+	"example",
+	"invalid",
+	"onion",
+	"nip.io",
+	"sslip.io",
+	"xip.io",
+	"localtest.me",
+	"lvh.me",
+	"vcap.me",
+	"traefik.me"
+];
+/**
+* Host exato para next/image (images.remoteHosts). Sem curinga (vira proxy aberto no
+* /_next/image), sem protocolo, caminho, porta ou IP; só minúsculas e com pelo menos um ponto;
+* nem sufixo de hospedagem pública, nem rede interna.
+*/
+const hostnameSchema = z.string().refine((v) => {
+	const labels = v.split(".");
+	return v.length <= 253 && labels.length >= 2 && labels.every((l) => LABEL_RE.test(l)) && /[a-z]/.test(labels[labels.length - 1]);
+}, {
+	error: "host inválido: use só o nome exato, sem curinga, protocolo, caminho, porta ou IP (ex.: ik.imagekit.io)",
+	abort: true
+}).refine((v) => !PUBLIC_SUFFIX_HOSTS.includes(v), {
+	error: (iss) => `"${String(iss.input)}" é um sufixo de hospedagem pública: liberaria as imagens de qualquer site desse provedor. Use o host do seu site (ex.: meu-site.${String(iss.input)})`,
+	abort: true
+}).refine((v) => !PRIVATE_HOST_SUFFIXES.some((s) => v === s || v.endsWith(`.${s}`)), { error: (iss) => `"${String(iss.input)}" é de rede interna ou de DNS curinga (resolve para qualquer IP): use um host público` });
+/** Lista sem repetição; a repetida aponta o índice no caminho do erro. */
+function uniqueItems(what) {
+	return (list, ctx) => {
+		list.forEach((item, i) => {
+			if (list.indexOf(item) !== i) ctx.addIssue({
+				code: "custom",
+				message: `${what} repetido: ${String(item)}`,
+				path: [i]
+			});
+		});
+	};
+}
+//#endregion
+//#region src/catalog.ts
+/** Hosts aceitos por plataforma (dado, não contrato: acrescentar host é PR ao arquiteto). */
+const PLATFORM_HOSTS = {
+	mercadoLivre: [
+		"mercadolivre.com.br",
+		"mercadolivre.com",
+		"mercadolibre.com"
+	],
+	shopee: [
+		"shopee.com.br",
+		"shopee.com",
+		"shope.ee"
+	],
+	amazon: [
+		"amazon.com.br",
+		"amazon.com",
+		"amzn.to",
+		"a.co"
+	]
+};
+const PLATFORM_MESSAGES = {
+	mercadoLivre: "mercadoLivreLink precisa ser um link https do Mercado Livre (ex.: https://produto.mercadolivre.com.br/...)",
+	shopee: "shopeeLink precisa ser um link https da Shopee (ex.: https://shopee.com.br/...)",
+	amazon: "amazonLink precisa ser um link https da Amazon (ex.: https://www.amazon.com.br/...)"
+};
+/** Link https de um marketplace: host da lista ou subdomínio, sem credenciais nem porta, até 2048. */
+function platformUrl(platform) {
+	return httpsUrlWith(PLATFORM_MESSAGES[platform], PLATFORM_HOSTS[platform]);
+}
+const specSchema = z.strictObject({
+	label: z.string().min(1).meta({
+		label: "Nome",
+		example: "Material"
+	}),
+	value: z.string().min(1).meta({
+		label: "Valor",
+		example: "Silicone"
+	})
+});
+const installmentSchema = z.strictObject({
+	/** número de parcelas, ex.: 10 */
+	count: z.number().int().positive().meta({
+		label: "Parcelas",
+		input: "number"
+	}),
+	/** valor de cada parcela */
+	value: z.number().positive().meta({
+		label: "Valor da parcela",
+		input: "number"
+	}),
+	/** se as parcelas têm juros; false = "sem juros" */
+	hasInterest: z.boolean().optional().meta({
+		label: "Com juros",
+		input: "confirm"
+	})
+});
+const catalogItemBase = z.object({
+	slug: slugSchema.meta({
+		label: "Slug",
+		description: "Nome do arquivo e parte da URL",
+		example: "capa-iphone-15"
+	}),
+	name: z.string().min(1).meta({ label: "Nome" }),
+	/** frase curta exibida nos cards e no topo da página de detalhe */
+	shortDescription: z.string().min(1).meta({ label: "Descrição curta" }),
+	/** texto completo exibido na página de detalhe */
+	description: z.string().min(1).meta({
+		label: "Descrição completa",
+		input: "multiline"
+	}),
+	images: z.array(imageSrc).min(1).meta({
+		label: "Imagens",
+		input: "image",
+		description: "A primeira é a capa"
+	}),
+	specs: z.array(specSchema).optional().meta({ label: "Especificações" }),
+	/** posição na lista (crescente); sem order vai para o fim; empate por slug */
+	order: z.number().int().nonnegative().optional().meta({
+		label: "Ordem",
+		input: "number"
+	})
+});
+const productSchema = catalogItemBase.extend({
+	kind: z.literal("product"),
+	category: z.string().min(1).meta({ label: "Categoria" }),
+	/** preço à vista */
+	price: z.number().nonnegative().meta({
+		label: "Preço à vista",
+		input: "number"
+	}),
+	/** preço "de"; maior que price gera o selo de oferta */
+	originalPrice: z.number().positive().optional().meta({
+		label: "Preço original",
+		input: "number",
+		ask: "optional"
+	}),
+	installment: installmentSchema.optional().meta({ label: "Parcelamento" }),
+	/** 0 = sob encomenda */
+	stockQty: z.number().int().nonnegative().meta({
+		label: "Estoque",
+		input: "number",
+		description: "0 = sob encomenda"
+	}),
+	whatsappButton: z.boolean().default(true).meta({
+		label: "Botão do WhatsApp",
+		input: "confirm"
+	}),
+	mercadoLivreLink: platformUrl("mercadoLivre").optional().meta({
+		label: "Link do Mercado Livre",
+		input: "url",
+		ask: "optional"
+	}),
+	shopeeLink: platformUrl("shopee").optional().meta({
+		label: "Link da Shopee",
+		input: "url",
+		ask: "optional"
+	}),
+	amazonLink: platformUrl("amazon").optional().meta({
+		label: "Link da Amazon",
+		input: "url",
+		ask: "optional"
+	}),
+	externalLink: httpsUrlWith("externalLink precisa começar com https://").optional().meta({
+		label: "Link de outra loja",
+		input: "url",
+		ask: "optional"
+	})
+}).strict();
+const serviceSchema = catalogItemBase.extend({ kind: z.literal("service") }).strict();
+/** content/products/<slug>.json: sem kind e sem slug (vêm do diretório e do nome do arquivo). */
+const productContentSchema = productSchema.omit({
+	kind: true,
+	slug: true
+});
+/** content/services/<slug>.json */
+const serviceContentSchema = serviceSchema.omit({
+	kind: true,
+	slug: true
+});
+//#endregion
+//#region src/links.ts
+const label = z.string().min(1).meta({ label: "Texto do botão" });
+const siteLinkSchema = z.union([z.strictObject({
+	label,
+	href: siteHref.meta({
+		label: "Destino",
+		example: "/sobre",
+		input: "url"
+	})
+}), z.strictObject({
+	label,
+	whatsapp: z.union([z.literal(true), z.string().min(1)]).meta({
+		label: "Mensagem do WhatsApp",
+		description: "true = mensagem geral do site; um texto = mensagem própria"
+	})
+})]).meta({
+	label: "Botão",
+	input: "link"
+});
+/**
+* Metadados de campo, via .meta() (por último na cadeia, depois de .optional() e .default()).
+* Validados em runtime por defineSection: não há module augmentation do zod, para não mudar
+* o zod de quem instala o pacote.
+*/
+const fieldMetaSchema = z.strictObject({
+	/** obrigatório quando o campo é perguntado */
+	label: z.string().min(1).optional(),
+	/** ajuda na CLI e no hover do JSON */
+	description: z.string().min(1).optional(),
+	/** placeholder da pergunta e exemplo no erro */
+	example: z.string().optional(),
+	/** tipo de pergunta; ausente = inferido do tipo zod (pela CLI) */
+	input: z.enum([
+		"text",
+		"multiline",
+		"url",
+		"image",
+		"number",
+		"select",
+		"multiselect",
+		"confirm",
+		"icon",
+		"link"
+	]).optional(),
+	/** se a CLI pergunta; ausente = "always" se obrigatório, "never" se opcional */
+	ask: z.enum([
+		"always",
+		"optional",
+		"never"
+	]).optional(),
+	/** ordem das perguntas; ausente = ordem do objeto */
+	order: z.number().optional()
+});
+/** Campos comuns das seções (menos o hero, que só tem id). */
+const sectionBase = z.object({
+	id: z.string().regex(/^[a-z][a-z0-9-]*$/, { error: "use letras minúsculas, números e hífens (ex.: contato)" }).optional().meta({
+		label: "Âncora",
+		description: "Identificador para links do tipo #contato"
+	}),
+	title: z.string().min(1).optional().meta({
+		label: "Título",
+		ask: "optional"
+	}),
+	subtitle: z.string().min(1).optional().meta({
+		label: "Subtítulo",
+		ask: "optional"
+	})
+});
+/** Metadado do campo (o registrado na própria instância). */
+function fieldMeta(schema) {
+	return z.globalRegistry.get(schema);
+}
+function isOptional(schema) {
+	return schema instanceof z.ZodOptional || schema instanceof z.ZodDefault || schema instanceof z.ZodPrefault;
+}
+/** Se a CLI pergunta o campo: o ask do metadado, ou "always" se obrigatório e "never" se opcional. */
+function fieldAsk(schema) {
+	return fieldMeta(schema)?.ask ?? (isOptional(schema) ? "never" : "always");
+}
+function unwrap(schema) {
+	let s = schema;
+	while (s instanceof z.ZodOptional || s instanceof z.ZodDefault || s instanceof z.ZodPrefault || s instanceof z.ZodNullable) s = s.unwrap();
+	return s;
+}
+/** Problemas de metadado nos campos de um objeto, recursivo (listas, objetos e uniões). */
+function fieldProblems(shape, prefix = "") {
+	return Object.entries(shape).flatMap(([key, field]) => {
+		if (field instanceof z.ZodLiteral) return [];
+		const path = prefix + key;
+		const problems = [];
+		const meta = fieldMeta(field);
+		if (meta && !fieldMetaSchema.safeParse(meta).success) problems.push(`${path}: meta inválido (${JSON.stringify(meta)})`);
+		const ask = fieldAsk(field);
+		if (ask !== "never" && !meta?.label) problems.push(`${path} é perguntado (ask "${ask}") e não tem label`);
+		return [...problems, ...nested(unwrap(field), path)];
+	});
+}
+function nested(schema, path) {
+	if (schema instanceof z.ZodObject) return fieldProblems(schema.shape, `${path}.`);
+	if (schema instanceof z.ZodArray) return nested(unwrap(schema.element), `${path}[]`);
+	if (schema instanceof z.ZodUnion) return schema.options.flatMap((o) => nested(unwrap(o), path));
+	return [];
+}
+/** Monta o schema final da seção: os campos mais o type literal, strict. */
+function sectionSchemaOf(type, fields) {
+	return fields.extend({ type: z.literal(type) }).strict();
+}
+/**
+* Define uma seção. Falha na hora (na importação do pacote) se: o type não é kebab-case,
+* um metadado é inválido, um campo perguntado não tem label, ou um preset não valida.
+*/
+function defineSection(def) {
+	const where = `defineSection("${def.type}")`;
+	if (!/^[a-z]+(?:-[a-z]+)*$/.test(def.type)) throw new Error(`${where}: o type precisa ser kebab-case`);
+	const problems = fieldProblems(def.fields.shape);
+	if (problems.length) throw new Error(`${where}: ${problems.join("; ")}`);
+	const schema = sectionSchemaOf(def.type, def.fields);
+	const presets = def.presets ?? [];
+	for (const preset of presets) {
+		const r = schema.safeParse({
+			...preset.value,
+			type: def.type
+		});
+		if (!r.success) throw new Error(`${where}: preset "${preset.id}" não valida: ${r.error.message}`);
+	}
+	return {
+		type: def.type,
+		module: def.module,
+		label: def.label,
+		description: def.description,
+		schema,
+		presets,
+		limits: def.limits ?? {}
+	};
+}
+//#endregion
+//#region src/sections/benefits.ts
+const benefits = defineSection({
+	type: "benefits",
+	module: "core",
+	label: "Benefícios",
+	description: "Lista de vantagens com ícone, título e texto curto.",
+	fields: sectionBase.extend({ items: z.array(z.strictObject({
+		icon: z.enum(SECTION_ICONS).meta({
+			label: "Ícone",
+			input: "icon"
+		}),
+		title: z.string().min(1).meta({ label: "Título" }),
+		text: z.string().min(1).meta({
+			label: "Texto",
+			input: "multiline"
+		})
+	})).min(1).meta({
+		label: "Benefícios",
+		ask: "always"
+	}) }),
+	presets: [{
+		id: "basico",
+		label: "3 benefícios de exemplo",
+		value: {
+			title: "Por que escolher a gente",
+			items: [
+				{
+					icon: "shield-check",
+					title: "Garantia",
+					text: "Garantia por escrito em todo atendimento."
+				},
+				{
+					icon: "clock",
+					title: "Rapidez",
+					text: "Resposta no mesmo dia pelo WhatsApp."
+				},
+				{
+					icon: "hand-coins",
+					title: "Preço justo",
+					text: "Orçamento claro antes de começar."
+				}
+			]
+		}
+	}]
+});
+//#endregion
+//#region src/sections/contact.ts
+const contact = defineSection({
+	type: "contact",
+	module: "core",
+	label: "Contato",
+	description: "Telefone, e-mail, endereço, horário e mapa, a partir de siteConfig.contact.",
+	fields: sectionBase.extend({ 
+	/** mostra o mapa de siteConfig.contact.mapEmbedUrl */
+showMap: z.boolean().optional().meta({
+		label: "Mostrar o mapa",
+		input: "confirm"
+	}) })
+});
+//#endregion
+//#region src/sections/cta-banner.ts
+const ctaBanner = defineSection({
+	type: "cta-banner",
+	module: "core",
+	label: "Chamada para ação",
+	description: "Faixa de destaque com texto curto e um botão.",
+	fields: sectionBase.extend({
+		text: z.string().min(1).optional().meta({
+			label: "Texto",
+			input: "multiline",
+			ask: "optional"
+		}),
+		cta: siteLinkSchema.meta({
+			label: "Botão",
+			input: "link"
+		}),
+		/** cor de fundo: primária, cor de ação ou discreta */
+		tone: z.enum([
+			"primary",
+			"cta",
+			"muted"
+		]).optional().meta({
+			label: "Cor de fundo",
+			input: "select"
+		})
+	})
+});
+//#endregion
+//#region src/sections/faq.ts
+const faq = defineSection({
+	type: "faq",
+	module: "core",
+	label: "Perguntas frequentes",
+	description: "Perguntas e respostas, com dados estruturados para o Google.",
+	fields: sectionBase.extend({ items: z.array(z.strictObject({
+		question: z.string().min(1).meta({ label: "Pergunta" }),
+		answer: z.string().min(1).meta({
+			label: "Resposta",
+			input: "multiline"
+		})
+	})).min(1).meta({
+		label: "Perguntas",
+		ask: "always"
+	}) }),
+	presets: [{
+		id: "basico",
+		label: "3 perguntas de exemplo",
+		value: {
+			title: "Dúvidas frequentes",
+			items: [
+				{
+					question: "Como faço um orçamento?",
+					answer: "Fale com a gente pelo WhatsApp e responda algumas perguntas rápidas."
+				},
+				{
+					question: "Quais as formas de pagamento?",
+					answer: "Pix, débito e crédito."
+				},
+				{
+					question: "Vocês dão garantia?",
+					answer: "Sim, com termo por escrito."
+				}
+			]
+		}
+	}],
+	limits: { maxPerPage: 1 }
+});
+//#endregion
+//#region src/sections/gallery.ts
+const gallery = defineSection({
+	type: "gallery",
+	module: "gallery",
+	label: "Galeria de projetos",
+	description: "Fotos de public/ultimos_projetos, com link para a galeria completa.",
+	fields: sectionBase.extend({ limit: z.number().int().positive().optional().meta({
+		label: "Quantidade máxima de fotos",
+		input: "number"
+	}) })
+});
+//#endregion
+//#region src/sections/hero.ts
+const slide = z.strictObject({
+	image: imageSrc.meta({
+		label: "Imagem",
+		input: "image",
+		example: "/home/slide-1.jpg"
+	}),
+	alt: z.string().min(1).meta({
+		label: "Descrição da imagem",
+		description: "Texto alternativo, para leitores de tela"
+	}),
+	title: z.string().min(1).meta({ label: "Título" }),
+	subtitle: z.string().min(1).optional().meta({
+		label: "Subtítulo",
+		ask: "optional"
+	}),
+	/** botão principal do slide */
+	cta: siteLinkSchema.optional().meta({
+		label: "Botão principal",
+		input: "link"
+	}),
+	/** segundo botão, com estilo discreto */
+	secondaryCta: siteLinkSchema.optional().meta({
+		label: "Botão secundário",
+		input: "link"
+	}),
+	/** torna o slide inteiro clicável (útil para banners de promoção sem botão) */
+	href: siteHref.optional().meta({
+		label: "Link do slide inteiro",
+		input: "url"
+	}),
+	/** posição do texto */
+	align: z.enum([
+		"left",
+		"center",
+		"right"
+	]).optional().meta({
+		label: "Alinhamento do texto",
+		input: "select"
+	})
+});
+const hero = defineSection({
+	type: "hero",
+	module: "core",
+	label: "Banner principal",
+	description: "Carrossel de imagens grandes com título e botões.",
+	fields: sectionBase.pick({ id: true }).extend({
+		slides: z.array(slide).min(1).meta({
+			label: "Slides",
+			ask: "always"
+		}),
+		autoplay: z.boolean().optional().meta({
+			label: "Passar sozinho",
+			input: "confirm"
+		}),
+		/** ms entre slides */
+		interval: z.number().int().positive().optional().meta({
+			label: "Intervalo (ms)",
+			input: "number"
+		}),
+		height: z.enum([
+			"sm",
+			"md",
+			"lg",
+			"full"
+		]).optional().meta({
+			label: "Altura",
+			input: "select"
+		})
+	}),
+	presets: [{
+		id: "basico",
+		label: "Um slide com botão do WhatsApp",
+		value: {
+			height: "lg",
+			slides: [{
+				image: "/home/slide-1.jpg",
+				alt: "Foto principal da loja",
+				title: "Bem-vindo à nossa loja",
+				subtitle: "Atendimento rápido pelo WhatsApp.",
+				cta: {
+					label: "Fale com a gente",
+					whatsapp: true
+				}
+			}]
+		}
+	}],
+	limits: { maxPerPage: 1 }
+});
+//#endregion
+//#region src/sections/lead-form.ts
+/** Formulário de contato. O destino dos dados vem de siteConfig.leads. */
+const leadForm = defineSection({
+	type: "lead-form",
+	module: "core",
+	label: "Formulário de contato",
+	description: "Formulário de orçamento; os dados vão para o WhatsApp ou para um serviço de formulários.",
+	fields: sectionBase.extend({
+		/** campos, na ordem; em branco = nome, telefone e mensagem */
+		fields: z.array(z.enum(LEAD_FIELDS)).superRefine(uniqueItems("campo")).optional().meta({
+			label: "Campos",
+			input: "multiselect"
+		}),
+		submitLabel: z.string().min(1).optional().meta({ label: "Texto do botão de envio" }),
+		/** texto de consentimento (LGPD) exibido com uma caixa de seleção obrigatória */
+		consentText: z.string().min(1).optional().meta({
+			label: "Texto de consentimento (LGPD)",
+			input: "multiline"
+		})
+	})
+});
+//#endregion
+//#region src/sections/products.ts
+const products = defineSection({
+	type: "products",
+	module: "products",
+	label: "Produtos em destaque",
+	description: "Lista de produtos do catálogo, com link para a página de produtos.",
+	fields: sectionBase.extend({
+		category: z.string().min(1).optional().meta({
+			label: "Categoria",
+			ask: "optional"
+		}),
+		limit: z.number().int().positive().optional().meta({
+			label: "Quantidade máxima",
+			input: "number"
+		})
+	})
+});
+//#endregion
+//#region src/sections/services.ts
+const services = defineSection({
+	type: "services",
+	module: "services",
+	label: "Serviços em destaque",
+	description: "Lista de serviços do catálogo, com link para a página de serviços.",
+	fields: sectionBase.extend({ limit: z.number().int().positive().optional().meta({
+		label: "Quantidade máxima",
+		input: "number"
+	}) })
+});
+//#endregion
+//#region src/sections/stats.ts
+const stats = defineSection({
+	type: "stats",
+	module: "core",
+	label: "Números",
+	description: "Números de destaque (anos de experiência, clientes atendidos...).",
+	fields: sectionBase.extend({ items: z.array(z.strictObject({
+		value: z.string().min(1).meta({
+			label: "Número",
+			example: "10+"
+		}),
+		label: z.string().min(1).meta({
+			label: "Legenda",
+			example: "anos de experiência"
+		})
+	})).min(1).meta({
+		label: "Números",
+		ask: "always"
+	}) }),
+	presets: [{
+		id: "basico",
+		label: "3 números de exemplo",
+		value: { items: [
+			{
+				value: "10+",
+				label: "anos de experiência"
+			},
+			{
+				value: "1.000+",
+				label: "clientes atendidos"
+			},
+			{
+				value: "4,9",
+				label: "nota média"
+			}
+		] }
+	}]
+});
+//#endregion
+//#region src/sections/testimonials.ts
+const testimonials = defineSection({
+	type: "testimonials",
+	module: "core",
+	label: "Depoimentos",
+	description: "Opiniões de clientes, com nota de 1 a 5.",
+	fields: sectionBase.extend({ items: z.array(z.strictObject({
+		name: z.string().min(1).meta({ label: "Nome" }),
+		text: z.string().min(1).meta({
+			label: "Depoimento",
+			input: "multiline"
+		}),
+		role: z.string().min(1).optional().meta({
+			label: "Descrição",
+			example: "Troca de tela",
+			ask: "optional"
+		}),
+		rating: z.literal([
+			1,
+			2,
+			3,
+			4,
+			5
+		]).optional().meta({
+			label: "Nota",
+			input: "select"
+		}),
+		image: imageSrc.optional().meta({
+			label: "Foto",
+			input: "image"
+		})
+	})).min(1).meta({
+		label: "Depoimentos",
+		ask: "always"
+	}) }),
+	presets: [{
+		id: "basico",
+		label: "2 depoimentos de exemplo",
+		value: {
+			title: "O que dizem nossos clientes",
+			items: [{
+				name: "Cliente 1",
+				rating: 5,
+				text: "Atendimento rápido e atencioso. Recomendo."
+			}, {
+				name: "Cliente 2",
+				rating: 5,
+				text: "Resolveram no mesmo dia, com garantia."
+			}]
+		}
+	}]
+});
+//#endregion
+//#region src/sections/text-image.ts
+const textImage = defineSection({
+	type: "text-image",
+	module: "core",
+	label: "Texto e imagem",
+	description: "Texto em parágrafos ao lado de uma imagem.",
+	fields: sectionBase.extend({
+		/** parágrafos separados por linha em branco */
+		text: z.string().min(1).meta({
+			label: "Texto",
+			input: "multiline",
+			description: "Parágrafos separados por linha em branco"
+		}),
+		image: imageSrc.meta({
+			label: "Imagem",
+			input: "image"
+		}),
+		imageAlt: z.string().min(1).meta({ label: "Descrição da imagem" }),
+		imageSide: z.enum(["left", "right"]).optional().meta({
+			label: "Lado da imagem",
+			input: "select"
+		}),
+		cta: siteLinkSchema.optional().meta({
+			label: "Botão",
+			input: "link"
+		})
+	})
+});
+//#endregion
+//#region src/sections/widget.ts
+/**
+* Código de widget colado (avaliações do TripAdvisor, Reclame Aqui, Trustpilot, Elfsight...).
+* Os <script> do código rodam no navegador: é conteúdo de confiança do dono do site.
+*/
+const widget = defineSection({
+	type: "widget",
+	module: "core",
+	label: "Widget externo",
+	description: "Código de widget colado de outra plataforma (avaliações, agenda...). Os scripts rodam no navegador.",
+	fields: sectionBase.extend({
+		html: z.string().min(1).meta({
+			label: "Código do widget",
+			input: "multiline"
+		}),
+		/** altura mínima reservada enquanto o widget carrega, ex.: "320px" */
+		minHeight: cssLength.optional().meta({
+			label: "Altura mínima",
+			example: "320px"
+		})
+	})
+});
+//#endregion
+//#region src/sections/index.ts
+/** Todas as definições, na ordem de hoje: as do núcleo e depois as dos módulos. */
+const sectionDefinitions = [
+	hero,
+	benefits,
+	textImage,
+	ctaBanner,
+	testimonials,
+	stats,
+	faq,
+	contact,
+	leadForm,
+	widget,
+	products,
+	services,
+	gallery
+];
+const sectionSchema = z.discriminatedUnion("type", [
+	hero.schema,
+	benefits.schema,
+	textImage.schema,
+	ctaBanner.schema,
+	testimonials.schema,
+	stats.schema,
+	faq.schema,
+	contact.schema,
+	leadForm.schema,
+	widget.schema,
+	products.schema,
+	services.schema,
+	gallery.schema
+]);
+const SECTION_TYPES = sectionDefinitions.map((d) => d.type);
+function getSectionDefinition(type) {
+	const def = sectionDefinitions.find((d) => d.type === type);
+	if (!def) throw new Error(`Seção desconhecida: "${type}". Tipos válidos: ${SECTION_TYPES.join(", ")}`);
+	return def;
+}
+/** Tipos de seção de um módulo ("core" = sempre presentes). */
+function sectionsOfModule(module) {
+	return sectionDefinitions.filter((d) => d.module === module).map((d) => d.type);
+}
+//#endregion
+//#region src/page.ts
+/** Slugs que não podem ser página (rotas dos módulos e do Next), mesmo com o módulo desligado. */
+const RESERVED_PAGE_SLUGS = [
+	"produtos",
+	"produto",
+	"servicos",
+	"servico",
+	"ultimos-projetos",
+	"api",
+	"_next",
+	"home"
+];
+const pageSlugSchema = slugSchema.refine((s) => !RESERVED_PAGE_SLUGS.includes(s), { error: (iss) => `"${String(iss.input)}" é reservado (${RESERVED_PAGE_SLUGS.join(", ")}): escolha outro slug` });
+function sectionList(where) {
+	return z.array(sectionSchema).superRefine((sections, ctx) => {
+		const counts = /* @__PURE__ */ new Map();
+		sections.forEach((section, i) => {
+			const { limits, label } = getSectionDefinition(section.type);
+			const n = (counts.get(section.type) ?? 0) + 1;
+			counts.set(section.type, n);
+			if (limits.maxPerPage !== void 0 && n > limits.maxPerPage) ctx.addIssue({
+				code: "custom",
+				path: [i],
+				message: `a seção "${section.type}" (${label}) pode aparecer no máximo ${limits.maxPerPage} vez(es) por página`
+			});
+			if (limits.homeOnly && where === "page") ctx.addIssue({
+				code: "custom",
+				path: [i],
+				message: `a seção "${section.type}" (${label}) só pode ficar na home`
+			});
+		});
+	});
+}
+const homeSchema = z.strictObject({ sections: sectionList("home").meta({ label: "Seções" }) });
+const pageSchema = z.strictObject({
+	title: z.string().min(1).meta({ label: "Título da página" }),
+	description: z.string().min(1).optional().meta({
+		label: "Descrição (SEO)",
+		ask: "optional"
+	}),
+	sections: sectionList("page").meta({
+		label: "Seções",
+		ask: "never"
+	})
+});
+//#endregion
+export { slugSchema as A, serviceSchema as C, imageSrc as D, httpsUrl as E, urlProblem as M, ptBRError as O, serviceContentSchema as S, hostnameSchema as T, catalogItemBase as _, SECTION_TYPES as a, productContentSchema as b, sectionSchema as c, fieldAsk as d, fieldMeta as f, PLATFORM_HOSTS as g, siteLinkSchema as h, pageSlugSchema as i, uniqueItems as j, siteHref as k, sectionsOfModule as l, sectionBase as m, homeSchema as n, getSectionDefinition as o, fieldMetaSchema as p, pageSchema as r, sectionDefinitions as s, RESERVED_PAGE_SLUGS as t, defineSection as u, installmentSchema as v, cssValue as w, productSchema as x, platformUrl as y };