@organizapp/site-kit 0.0.1 → 0.4.0

package/dist/index.js

@@ -1,6 +1,13 @@
 // @organizapp/site-kit
 //
-// Vacío en W-0: existe para publicar la primera versión y dejar probada la
-// cadena (workflow, procedencia, plantilla). `getSiteProfile`, `<InquiryForm>`,
-// `submitInquiry` y `revalidateHandler` llegan con W-1 (docs/domain/website.md).
-export {};
+// Lo del SERVIDOR del sitio: firma con `ORGANIZAPP_SITE_SECRET`, así que nunca
+// se importa desde un Client Component. El formulario sale por
+// `@organizapp/site-kit/form`. Uso y contrato en el README.
+export { createFormSeal } from "./inquiry/form-seal.js";
+export { handleInquiryForm } from "./inquiry/handle-inquiry-form.js";
+export { MARKETING_OPT_IN_VERSION, marketingOptInText } from "./inquiry/marketing-opt-in.js";
+export { submitInquiry } from "./inquiry/submit-inquiry.js";
+export { clientIpFromHeaders, revalidationFromEnv, siteConnectionFromEnv } from "./inquiry/site-environment.js";
+export { getSiteProfile } from "./profile/get-site-profile.js";
+export { SITE_PROFILE_TAG, createRevalidateHandler } from "./profile/revalidate-handler.js";
+export { CHAT_COOKIE, CHAT_COOKIE_OPTIONS, sendChatMessage } from "./chat/send-chat-message.js";

package/dist/inquiry/form-seal.d.ts

@@ -0,0 +1,18 @@
+/**
+ * El sello de hora del formulario (W16): el servidor del sitio firma cuándo
+ * dibujó el formulario, y al recibirlo mira cuánto pasó. Una persona no
+ * completa un formulario en menos de 2 segundos; un formulario de hace más de
+ * 24 horas se recarga antes de mandarse. La hora va firmada con el secreto del
+ * sitio: cambiarla a mano invalida el sello.
+ */
+export declare const SEAL_MIN_AGE_MS = 2000;
+export declare const SEAL_MAX_AGE_MS: number;
+export type SealCheck = "ok" | "too_fast" | "expired" | "invalid";
+export declare function createFormSeal(input: {
+    readonly secret: string;
+    readonly nowMs: number;
+}): Promise<string>;
+export declare function checkFormSeal(seal: string, input: {
+    readonly secret: string;
+    readonly nowMs: number;
+}): Promise<SealCheck>;

package/dist/inquiry/form-seal.js

@@ -0,0 +1,34 @@
+import { hmacSign, hmacVerify } from "../crypto/hmac.js";
+/**
+ * El sello de hora del formulario (W16): el servidor del sitio firma cuándo
+ * dibujó el formulario, y al recibirlo mira cuánto pasó. Una persona no
+ * completa un formulario en menos de 2 segundos; un formulario de hace más de
+ * 24 horas se recarga antes de mandarse. La hora va firmada con el secreto del
+ * sitio: cambiarla a mano invalida el sello.
+ */
+export const SEAL_MIN_AGE_MS = 2_000;
+export const SEAL_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+/** Lo que se tolera entre relojes de dos instancias del mismo sitio. */
+const SKEW_MS = 5_000;
+const PREFIX = "organizapp-form-seal:v1:";
+export async function createFormSeal(input) {
+    const issuedAt = String(Math.trunc(input.nowMs));
+    return `${issuedAt}.${await hmacSign(input.secret, PREFIX + issuedAt)}`;
+}
+export async function checkFormSeal(seal, input) {
+    const parts = seal.split(".");
+    const [issuedAt = "", signature = ""] = parts;
+    if (parts.length !== 2 || !/^\d{1,15}$/u.test(issuedAt))
+        return "invalid";
+    // La firma primero: una hora que no firmó el sitio no dice nada.
+    if (!(await hmacVerify(input.secret, PREFIX + issuedAt, signature)))
+        return "invalid";
+    const age = input.nowMs - Number(issuedAt);
+    if (age < -SKEW_MS)
+        return "invalid";
+    if (age < SEAL_MIN_AGE_MS)
+        return "too_fast";
+    if (age > SEAL_MAX_AGE_MS)
+        return "expired";
+    return "ok";
+}

package/dist/inquiry/form-state.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Lo que comparten el formulario (navegador) y su acción (servidor): los
+ * nombres de los campos y el estado que vuelve. Sin código de servidor: esto
+ * sí llega al bundle del navegador.
+ */
+export declare const INQUIRY_FIELD: {
+    readonly name: "name";
+    readonly phone: "phone";
+    readonly email: "email";
+    readonly message: "message";
+    readonly marketingOptIn: "marketingOptIn";
+    readonly seal: "organizapp_seal";
+    /** El campo trampa. Un nombre que un bot quiere llenar y una persona no ve. */
+    readonly honeypot: "website";
+    readonly turnstile: "cf-turnstile-response";
+};
+/** Qué exige el sitio de los dos medios de contacto: lo mismo que eligió en el CRM. */
+export type InquiryContactRequirement = "either" | "phone" | "email" | "both";
+/**
+ * `sent` también es la respuesta a un envío que se descartó por bot: quien lo
+ * mandó no aprende qué lo delató.
+ */
+export type InquiryFormState = {
+    readonly status: "idle";
+} | {
+    readonly status: "sent";
+} | {
+    readonly status: "invalid";
+    readonly field: string;
+} | {
+    readonly status: "reload";
+} | {
+    readonly status: "rate_limited";
+} | {
+    readonly status: "failed";
+};

package/dist/inquiry/form-state.js

@@ -0,0 +1,16 @@
+/**
+ * Lo que comparten el formulario (navegador) y su acción (servidor): los
+ * nombres de los campos y el estado que vuelve. Sin código de servidor: esto
+ * sí llega al bundle del navegador.
+ */
+export const INQUIRY_FIELD = {
+    name: "name",
+    phone: "phone",
+    email: "email",
+    message: "message",
+    marketingOptIn: "marketingOptIn",
+    seal: "organizapp_seal",
+    /** El campo trampa. Un nombre que un bot quiere llenar y una persona no ve. */
+    honeypot: "website",
+    turnstile: "cf-turnstile-response",
+};

package/dist/inquiry/handle-inquiry-form.d.ts

@@ -0,0 +1,21 @@
+import { type InquiryFormState } from "./form-state.js";
+import type { SiteConnection } from "./inquiry-fields.js";
+/**
+ * La acción del formulario, para la Server Action del sitio. En orden: campo
+ * trampa, sello de hora, Turnstile si está prendido, y recién ahí la API. Lo
+ * que delata a un bot responde las mismas gracias que un envío bueno y no gasta
+ * el cupo del sitio; un sello vencido pide recargar, que es lo que le pasa a
+ * una persona que dejó la pestaña abierta.
+ */
+export interface InquiryFormOptions {
+    readonly connection: SiteConnection;
+    /** `clientIpFromHeaders(await headers())` en Next. Sin IP no se firma. */
+    readonly clientIp: string | null;
+    readonly sourcePath: string;
+    readonly policyVersion: string;
+    /** Prende Turnstile. Ausente, el formulario no lo pide. */
+    readonly turnstileSecret?: string;
+    readonly nowMs?: number;
+    readonly fetch?: typeof fetch;
+}
+export declare function handleInquiryForm(data: FormData, options: InquiryFormOptions): Promise<InquiryFormState>;

package/dist/inquiry/handle-inquiry-form.js

@@ -0,0 +1,55 @@
+import { checkFormSeal } from "./form-seal.js";
+import { INQUIRY_FIELD } from "./form-state.js";
+import { inquiryIdempotencyKey } from "./idempotency-key.js";
+import { MARKETING_OPT_IN_VERSION } from "./marketing-opt-in.js";
+import { submitInquiry } from "./submit-inquiry.js";
+import { verifyTurnstile } from "./turnstile.js";
+const SENT = { status: "sent" };
+function text(data, name) {
+    const value = data.get(name);
+    return typeof value === "string" ? value.trim() : "";
+}
+function readFields(data, options) {
+    const phone = text(data, INQUIRY_FIELD.phone);
+    const email = text(data, INQUIRY_FIELD.email);
+    const optIn = data.get(INQUIRY_FIELD.marketingOptIn) !== null;
+    return {
+        name: text(data, INQUIRY_FIELD.name),
+        ...(phone === "" ? {} : { phone }),
+        ...(email === "" ? {} : { email }),
+        message: text(data, INQUIRY_FIELD.message),
+        sourcePath: options.sourcePath,
+        policyVersion: options.policyVersion,
+        marketingOptIn: optIn,
+        ...(optIn ? { marketingOptInVersion: MARKETING_OPT_IN_VERSION } : {}),
+    };
+}
+export async function handleInquiryForm(data, options) {
+    if (text(data, INQUIRY_FIELD.honeypot) !== "")
+        return SENT;
+    const seal = text(data, INQUIRY_FIELD.seal);
+    const nowMs = options.nowMs ?? Date.now();
+    const check = await checkFormSeal(seal, { secret: options.connection.siteSecret, nowMs });
+    if (check === "expired")
+        return { status: "reload" };
+    if (check !== "ok")
+        return SENT;
+    if (options.clientIp === null)
+        return { status: "failed" };
+    const fetcher = options.fetch === undefined ? {} : { fetch: options.fetch };
+    if (options.turnstileSecret !== undefined) {
+        const human = await verifyTurnstile({
+            token: text(data, INQUIRY_FIELD.turnstile), secret: options.turnstileSecret, clientIp: options.clientIp, ...fetcher,
+        });
+        if (!human)
+            return SENT;
+    }
+    const fields = readFields(data, options);
+    const idempotencyKey = await inquiryIdempotencyKey(options.connection.siteSecret, seal, fields);
+    const result = await submitInquiry({ fields, idempotencyKey, clientIp: options.clientIp }, options.connection, { ...fetcher, nowSeconds: Math.floor(nowMs / 1000) });
+    if (result.status === "sent" || result.status === "invalid")
+        return result;
+    if (result.status === "rate_limited")
+        return { status: "rate_limited" };
+    return { status: "failed" };
+}

package/dist/inquiry/idempotency-key.d.ts

@@ -0,0 +1,2 @@
+import type { InquiryFields } from "./inquiry-fields.js";
+export declare function inquiryIdempotencyKey(secret: string, seal: string, fields: InquiryFields): Promise<string>;

package/dist/inquiry/idempotency-key.js

@@ -0,0 +1,24 @@
+import { hmacBytes } from "../crypto/hmac.js";
+/**
+ * La clave de idempotencia de un envío, derivada de la carga de la página (el
+ * sello) y de lo escrito. Así se cumple lo que pide la API: la misma clave en
+ * cada reintento del MISMO envío (un doble clic, una red que se cortó) y otra si
+ * cambió el contenido —corregir el email después de un error es otro envío, y
+ * con la misma clave la API respondería conflicto—. Firmada con el secreto del
+ * sitio: nadie de afuera puede adivinar la clave de otra persona.
+ */
+const PREFIX = "organizapp-inquiry-key:v1:";
+function hex(bytes) {
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+export async function inquiryIdempotencyKey(secret, seal, fields) {
+    const content = JSON.stringify([
+        fields.name, fields.phone ?? "", fields.email ?? "", fields.message, fields.sourcePath, fields.policyVersion, fields.marketingOptIn,
+    ]);
+    const bytes = (await hmacBytes(secret, `${PREFIX}${seal}\n${content}`)).slice(0, 16);
+    // Forma de UUID versión 8 (la de los formatos propios) con la variante RFC.
+    bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x80;
+    bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80;
+    const text = hex(bytes);
+    return `${text.slice(0, 8)}-${text.slice(8, 12)}-${text.slice(12, 16)}-${text.slice(16, 20)}-${text.slice(20)}`;
+}

package/dist/inquiry/inquiry-fields.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Lo que viaja a `POST /api/sites/v1/inquiries`, menos la clave. El contrato
+ * vive en `docs/domain/website/inquiries.md` de Organizapp: el cuerpo es
+ * estricto y un campo de más rechaza el pedido entero.
+ */
+export interface InquiryFields {
+    readonly name: string;
+    /** Lo que no se llenó no se manda. */
+    readonly phone?: string;
+    readonly email?: string;
+    readonly message: string;
+    /** La ruta de la página del formulario, con `/` adelante y sin query. */
+    readonly sourcePath: string;
+    /** La versión de la política de privacidad que vio quien escribe. */
+    readonly policyVersion: string;
+    readonly marketingOptIn: boolean;
+    /** La versión del texto de novedades que vio. Solo con `marketingOptIn: true`. */
+    readonly marketingOptInVersion?: string;
+}
+/** Con qué sitio se habla: las tres variables del proyecto del sitio. */
+export interface SiteConnection {
+    readonly apiUrl: string;
+    readonly siteId: string;
+    readonly siteSecret: string;
+}

package/dist/inquiry/inquiry-fields.js

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

package/dist/inquiry/marketing-opt-in.d.ts

@@ -0,0 +1,11 @@
+/**
+ * El texto de la casilla de novedades. Lo fija el kit y no cada sitio, porque
+ * es la prueba del consentimiento: el CRM guarda la versión que se aceptó
+ * (W11), y un texto que cambia sin cambiar de versión dejaría una prueba falsa.
+ * La política de opt-in de Meta pide que diga por dónde llegan los mensajes y
+ * quién los manda; la casilla arranca sin marcar.
+ *
+ * Cambiar el texto es cambiar la versión, en el mismo commit.
+ */
+export declare const MARKETING_OPT_IN_VERSION = "wa-novedades-v1";
+export declare function marketingOptInText(businessName: string): string;

package/dist/inquiry/marketing-opt-in.js

@@ -0,0 +1,16 @@
+/**
+ * El texto de la casilla de novedades. Lo fija el kit y no cada sitio, porque
+ * es la prueba del consentimiento: el CRM guarda la versión que se aceptó
+ * (W11), y un texto que cambia sin cambiar de versión dejaría una prueba falsa.
+ * La política de opt-in de Meta pide que diga por dónde llegan los mensajes y
+ * quién los manda; la casilla arranca sin marcar.
+ *
+ * Cambiar el texto es cambiar la versión, en el mismo commit.
+ */
+export const MARKETING_OPT_IN_VERSION = "wa-novedades-v1";
+export function marketingOptInText(businessName) {
+    const name = businessName.trim();
+    if (name === "")
+        throw new Error("businessName: el texto de novedades tiene que nombrar al negocio");
+    return `Quiero recibir novedades de ${name} por WhatsApp.`;
+}

package/dist/inquiry/site-environment.d.ts

@@ -0,0 +1,19 @@
+import type { RevalidationConnection } from "../profile/revalidate-handler.js";
+import type { SiteConnection } from "./inquiry-fields.js";
+/**
+ * Las variables del proyecto del sitio. Ninguna lleva `NEXT_PUBLIC_`: no pueden
+ * llegar al navegador. Una que falta falla con su nombre, nunca con un valor.
+ */
+type Environment = Readonly<Record<string, string | undefined>>;
+export declare function siteConnectionFromEnv(env?: Environment): SiteConnection;
+/** Para la ruta del aviso: el secreto de revalidación, que el panel muestra junto con el de la API. */
+export declare function revalidationFromEnv(env?: Environment): RevalidationConnection;
+/**
+ * La IP de quien escribe, para el límite por persona de la API. En Vercel la
+ * primera de `x-forwarded-for` la pone la plataforma, no el navegador. Detrás
+ * de otro proxy, el sitio la saca él y se la pasa a `handleInquiryForm`.
+ */
+export declare function clientIpFromHeaders(headers: {
+    get(name: string): string | null;
+}): string | null;
+export {};

package/dist/inquiry/site-environment.js

@@ -0,0 +1,44 @@
+function required(env, name) {
+    const value = env[name]?.trim() ?? "";
+    if (value === "")
+        throw new Error(`site-kit: falta la variable ${name}`);
+    return value;
+}
+/** La API va por https: el secreto no viaja, pero el cuerpo lleva datos de una persona. */
+function apiUrl(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error("site-kit: ORGANIZAPP_API_URL no es una URL");
+    }
+    const local = url.hostname === "localhost" || url.hostname === "127.0.0.1";
+    if (url.protocol !== "https:" && !(local && url.protocol === "http:")) {
+        throw new Error("site-kit: ORGANIZAPP_API_URL tiene que ir por https");
+    }
+    return value;
+}
+export function siteConnectionFromEnv(env = process.env) {
+    return {
+        apiUrl: apiUrl(required(env, "ORGANIZAPP_API_URL")),
+        siteId: required(env, "ORGANIZAPP_SITE_ID"),
+        siteSecret: required(env, "ORGANIZAPP_SITE_SECRET"),
+    };
+}
+/** Para la ruta del aviso: el secreto de revalidación, que el panel muestra junto con el de la API. */
+export function revalidationFromEnv(env = process.env) {
+    return { siteId: required(env, "ORGANIZAPP_SITE_ID"), revalidationSecret: required(env, "ORGANIZAPP_REVALIDATION_SECRET") };
+}
+/**
+ * La IP de quien escribe, para el límite por persona de la API. En Vercel la
+ * primera de `x-forwarded-for` la pone la plataforma, no el navegador. Detrás
+ * de otro proxy, el sitio la saca él y se la pasa a `handleInquiryForm`.
+ */
+export function clientIpFromHeaders(headers) {
+    const forwarded = headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? "";
+    if (forwarded !== "")
+        return forwarded;
+    const real = headers.get("x-real-ip")?.trim() ?? "";
+    return real === "" ? null : real;
+}

package/dist/inquiry/submit-inquiry.d.ts

@@ -0,0 +1,30 @@
+import type { InquiryFields, SiteConnection } from "./inquiry-fields.js";
+/**
+ * Manda una consulta a Organizapp. Corre en el SERVIDOR del sitio, nunca en el
+ * navegador: firma con `ORGANIZAPP_SITE_SECRET`. La clave de idempotencia la
+ * trae quien llama y se repite en cada reintento: una red cortada a mitad de
+ * camino no dice si la consulta llegó, y repetir con la misma clave no duplica.
+ *
+ * Las respuestas de la API se traducen a cuatro desenlaces sin detalle
+ * interno: lo que se muestra a quien escribe lo decide el formulario.
+ */
+export type SubmitInquiryResult = {
+    readonly status: "sent";
+} | {
+    readonly status: "invalid";
+    readonly field: string;
+} | {
+    readonly status: "rate_limited";
+    readonly retryAfterSeconds: number | null;
+} | {
+    readonly status: "failed";
+    readonly reason: "unauthorized" | "conflict" | "unavailable" | "network" | "unexpected";
+};
+export declare function submitInquiry(input: {
+    readonly fields: InquiryFields;
+    readonly idempotencyKey: string;
+    readonly clientIp: string;
+}, connection: SiteConnection, deps?: {
+    readonly fetch?: typeof fetch;
+    readonly nowSeconds?: number;
+}): Promise<SubmitInquiryResult>;

package/dist/inquiry/submit-inquiry.js

@@ -0,0 +1,50 @@
+import { ASSERTION_HEADER, SITE_HEADER, signSiteAssertion } from "../assertion/site-assertion.js";
+const TIMEOUT_MS = 10_000;
+const PATH = "/api/sites/v1/inquiries";
+async function invalidField(response) {
+    try {
+        const body = (await response.json());
+        return typeof body.field === "string" ? body.field : "body";
+    }
+    catch {
+        return "body";
+    }
+}
+function retryAfter(response) {
+    const seconds = Number(response.headers.get("retry-after"));
+    return Number.isSafeInteger(seconds) && seconds > 0 ? seconds : null;
+}
+export async function submitInquiry(input, connection, deps = {}) {
+    const assertion = await signSiteAssertion({
+        secret: connection.siteSecret,
+        siteId: connection.siteId,
+        clientIp: input.clientIp,
+        nowSeconds: deps.nowSeconds ?? Math.floor(Date.now() / 1000),
+    });
+    let response;
+    try {
+        response = await (deps.fetch ?? fetch)(`${connection.apiUrl.replace(/\/+$/u, "")}${PATH}`, {
+            method: "POST",
+            headers: { "content-type": "application/json", [SITE_HEADER]: connection.siteId, [ASSERTION_HEADER]: assertion },
+            body: JSON.stringify({ idempotencyKey: input.idempotencyKey, ...input.fields }),
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+            cache: "no-store",
+        });
+    }
+    catch {
+        return { status: "failed", reason: "network" };
+    }
+    if (response.status === 201 || response.status === 200)
+        return { status: "sent" };
+    if (response.status === 422)
+        return { status: "invalid", field: await invalidField(response) };
+    if (response.status === 429)
+        return { status: "rate_limited", retryAfterSeconds: retryAfter(response) };
+    if (response.status === 401)
+        return { status: "failed", reason: "unauthorized" };
+    if (response.status === 409)
+        return { status: "failed", reason: "conflict" };
+    if (response.status === 503)
+        return { status: "failed", reason: "unavailable" };
+    return { status: "failed", reason: "unexpected" };
+}

package/dist/inquiry/turnstile.d.ts

@@ -0,0 +1,6 @@
+export declare function verifyTurnstile(input: {
+    readonly token: string;
+    readonly secret: string;
+    readonly clientIp: string;
+    readonly fetch?: typeof fetch;
+}): Promise<boolean>;

package/dist/inquiry/turnstile.js

@@ -0,0 +1,25 @@
+/**
+ * Turnstile de Cloudflare, apagado salvo que el sitio lo prenda (W16): se usa
+ * solo si aparece spam que el campo trampa y el sello no paran. Cualquier cosa
+ * que no sea un `success: true` explícito es un rechazo.
+ */
+const SITEVERIFY = "https://challenges.cloudflare.com/turnstile/v0/siteverify";
+const TIMEOUT_MS = 5_000;
+export async function verifyTurnstile(input) {
+    if (input.token === "")
+        return false;
+    try {
+        const response = await (input.fetch ?? fetch)(SITEVERIFY, {
+            method: "POST",
+            body: new URLSearchParams({ secret: input.secret, response: input.token, remoteip: input.clientIp }),
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+        if (!response.ok)
+            return false;
+        const body = (await response.json());
+        return body.success === true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/profile/get-site-profile.d.ts

@@ -0,0 +1,24 @@
+import type { SiteConnection } from "../inquiry/inquiry-fields.js";
+import { type SiteProfile } from "./site-profile.js";
+/**
+ * Lee los datos de la web del negocio. Corre en el SERVIDOR del sitio: firma con
+ * `ORGANIZAPP_SITE_SECRET`.
+ *
+ * **Sin caché propia, a propósito**: la firma cambia en cada pedido, y la caché de
+ * `fetch` de Next usa los headers en su clave, así que nunca acertaría. El sitio
+ * cachea el RESULTADO con la etiqueta `SITE_PROFILE_TAG` (`unstable_cache` o
+ * `"use cache"`), y `createRevalidateHandler` la invalida cuando el CRM avisa.
+ */
+export type SiteProfileResult = {
+    readonly status: "ok";
+    readonly profile: SiteProfile;
+} | {
+    readonly status: "not_set";
+} | {
+    readonly status: "failed";
+    readonly reason: "unauthorized" | "rate_limited" | "unavailable" | "network" | "unexpected";
+};
+export declare function getSiteProfile(connection: SiteConnection, deps?: {
+    readonly fetch?: typeof fetch;
+    readonly nowSeconds?: number;
+}): Promise<SiteProfileResult>;

package/dist/profile/get-site-profile.js

@@ -0,0 +1,41 @@
+import { ASSERTION_HEADER, SITE_HEADER, signSiteAssertion } from "../assertion/site-assertion.js";
+import { readSiteProfile } from "./site-profile.js";
+const TIMEOUT_MS = 10_000;
+const PATH = "/api/sites/v1/profile";
+export async function getSiteProfile(connection, deps = {}) {
+    const assertion = await signSiteAssertion({
+        secret: connection.siteSecret,
+        siteId: connection.siteId,
+        clientIp: "",
+        audience: "website:profile",
+        nowSeconds: deps.nowSeconds ?? Math.floor(Date.now() / 1000),
+    });
+    let response;
+    try {
+        response = await (deps.fetch ?? fetch)(`${connection.apiUrl.replace(/\/+$/u, "")}${PATH}`, {
+            headers: { [SITE_HEADER]: connection.siteId, [ASSERTION_HEADER]: assertion },
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+            cache: "no-store",
+        });
+    }
+    catch {
+        return { status: "failed", reason: "network" };
+    }
+    if (response.status === 404)
+        return { status: "not_set" };
+    if (response.status === 401)
+        return { status: "failed", reason: "unauthorized" };
+    if (response.status === 429)
+        return { status: "failed", reason: "rate_limited" };
+    if (response.status === 503)
+        return { status: "failed", reason: "unavailable" };
+    if (response.status !== 200)
+        return { status: "failed", reason: "unexpected" };
+    try {
+        const profile = readSiteProfile((await response.json()).profile);
+        return profile === null ? { status: "failed", reason: "unexpected" } : { status: "ok", profile };
+    }
+    catch {
+        return { status: "failed", reason: "unexpected" };
+    }
+}

package/dist/profile/revalidate-handler.d.ts

@@ -0,0 +1,19 @@
+/**
+ * La ruta `POST /api/organizapp/revalidate` del sitio: el CRM avisa que
+ * cambiaron los datos, y el sitio invalida lo que cacheó con `SITE_PROFILE_TAG`.
+ *
+ * El aviso viene firmado con el secreto de REVALIDACIÓN del sitio, distinto del
+ * de la API: quien tenga uno no puede usar el otro. Un aviso falso no cuesta
+ * más que una relectura, pero igual se rechaza. `revalidate` la trae el sitio
+ * (`revalidateTag` de `next/cache`): el kit no importa Next.
+ */
+export declare const SITE_PROFILE_TAG = "organizapp:site-profile";
+export interface RevalidationConnection {
+    readonly siteId: string;
+    readonly revalidationSecret: string;
+}
+export declare function createRevalidateHandler(options: {
+    readonly connection: RevalidationConnection;
+    readonly revalidate: (tag: string) => void | Promise<void>;
+    readonly nowSeconds?: () => number;
+}): (request: Request) => Promise<Response>;

package/dist/profile/revalidate-handler.js

@@ -0,0 +1,27 @@
+import { ASSERTION_HEADER, SITE_HEADER, verifySiteAssertion } from "../assertion/site-assertion.js";
+/**
+ * La ruta `POST /api/organizapp/revalidate` del sitio: el CRM avisa que
+ * cambiaron los datos, y el sitio invalida lo que cacheó con `SITE_PROFILE_TAG`.
+ *
+ * El aviso viene firmado con el secreto de REVALIDACIÓN del sitio, distinto del
+ * de la API: quien tenga uno no puede usar el otro. Un aviso falso no cuesta
+ * más que una relectura, pero igual se rechaza. `revalidate` la trae el sitio
+ * (`revalidateTag` de `next/cache`): el kit no importa Next.
+ */
+export const SITE_PROFILE_TAG = "organizapp:site-profile";
+export function createRevalidateHandler(options) {
+    const now = options.nowSeconds ?? (() => Math.floor(Date.now() / 1000));
+    return async (request) => {
+        if (request.method !== "POST")
+            return new Response(null, { status: 405, headers: { allow: "POST" } });
+        const site = request.headers.get(SITE_HEADER);
+        const assertion = request.headers.get(ASSERTION_HEADER);
+        const valid = site === options.connection.siteId && assertion !== null && await verifySiteAssertion(assertion, {
+            secret: options.connection.revalidationSecret, audience: "website:revalidate", siteId: options.connection.siteId, nowSeconds: now(),
+        });
+        if (!valid)
+            return new Response(null, { status: 401 });
+        await options.revalidate(SITE_PROFILE_TAG);
+        return new Response(null, { status: 204 });
+    };
+}

package/dist/profile/site-profile.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Los datos de la web que devuelve `GET /api/sites/v1/profile`. El contrato
+ * vive en `docs/domain/website.md` de Organizapp («Los datos de la web»).
+ */
+export interface SiteProfile {
+    readonly displayName: string;
+    readonly tagline: string | null;
+    /** Solo dígitos, con código de país (`5491140302370`): el sitio decide cómo mostrarlos. */
+    readonly phones: readonly string[];
+    readonly emails: readonly string[];
+    /** El número del botón «Escribinos por WhatsApp», en la misma forma: `https://wa.me/<número>`. */
+    readonly whatsapp: string | null;
+    readonly address: string | null;
+    readonly mapUrl: string | null;
+    /** Por día (`mon` … `sun`), tramos `HH:MM` ordenados; un día ausente es cerrado. */
+    readonly hours: Readonly<Record<string, readonly {
+        readonly open: string;
+        readonly close: string;
+    }[]>>;
+    /** La zona en la que está escrito el horario. */
+    readonly timeZone: string;
+    readonly socialLinks: readonly string[];
+    readonly updatedAt: string;
+}
+/** Lo que no tiene la forma del contrato no llega al sitio: es `null`. */
+export declare function readSiteProfile(value: unknown): SiteProfile | null;

package/dist/profile/site-profile.js

@@ -0,0 +1,21 @@
+const isText = (value) => typeof value === "string";
+const isTextOrNull = (value) => value === null || typeof value === "string";
+const isTextList = (value) => Array.isArray(value) && value.every(isText);
+const isRange = (value) => typeof value === "object" && value !== null
+    && isText(value["open"]) && isText(value["close"]);
+const isHours = (value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    && Object.values(value).every((ranges) => Array.isArray(ranges) && ranges.every(isRange));
+/** Lo que no tiene la forma del contrato no llega al sitio: es `null`. */
+export function readSiteProfile(value) {
+    if (typeof value !== "object" || value === null)
+        return null;
+    const s = value;
+    const { displayName, tagline, phones, emails, whatsapp, address, mapUrl, hours, timeZone, socialLinks, updatedAt } = s;
+    if (!isText(displayName) || !isTextOrNull(tagline) || !isTextList(phones) || !isTextList(emails))
+        return null;
+    if (!isTextOrNull(whatsapp) || !isTextOrNull(address) || !isTextOrNull(mapUrl) || !isHours(hours))
+        return null;
+    if (!isText(timeZone) || !isTextList(socialLinks) || !isText(updatedAt))
+        return null;
+    return { displayName, tagline, phones, emails, whatsapp, address, mapUrl, hours, timeZone, socialLinks, updatedAt };
+}