@inspira-npm/events 0.0.0-stage → 0.3.0

package/dist/server.d.ts

@@ -0,0 +1,141 @@
+import { t as AdClickRecordPayload } from "./click-record-B8KyALZZ.js";
+import { z } from "zod";
+/**
+ * IP del cliente desde los headers del request: `cf-connecting-ip`, `true-client-ip`, el primer
+ * valor de `x-forwarded-for` y `x-real-ip`, en ese orden. Salta los valores vacíos, inválidos o
+ * de relleno (`0`, `::1`, `127.0.0.1`…). Devuelve null si ninguno sirve.
+ */
+export declare function resolveClientIp(headers: Headers): string | null;
+/** Datos del usuario logueado, desde la sesión del sitio. Un campo ausente o vacío viaja `null`. */
+interface AdClickUser {
+  /** Id del usuario en Inspira. */
+  inspira_id?: string | number | null;
+  email?: string | null;
+  phone?: string | null;
+  /** Id del usuario en el sistema del cliente white-label. */
+  external_id?: string | number | null;
+  loyalty_id?: string | number | null;
+}
+/** Body de `POST {apiBase}/api/v1/ad-clicks` (ver docs/protocol.md). */
+interface AdClickRecordBody {
+  click_id: string;
+  ad_id: string;
+  token?: string;
+  placement: string;
+  position?: number;
+  page_url: string;
+  /** `ts` del navegador. */
+  client_ts?: string;
+  /** Hora del servidor del sitio al recibir el click. */
+  clicked_at: string;
+  org: number | null;
+  ip: string | null;
+  user_agent: string | null;
+  user: {
+    inspira_id: string | null;
+    email: string | null;
+    phone: string | null;
+    external_id: string | null;
+    loyalty_id: string | null;
+  } | null;
+}
+/** Credenciales y red para hablar con Laravel (`inspira-promotions-laravel`). */
+interface AdClickApiOptions {
+  /** URL base de Laravel, p. ej. `https://inspirapromotions.com` (sin `/api`). */
+  apiBase: string;
+  /** Cliente OAuth2 (client_credentials, scope `ad-clicks:write`) dado de alta en el admin. */
+  clientId: string;
+  /** Secreto del cliente. Solo servidor: nunca en una variable pública ni en el bundle. */
+  clientSecret: string;
+  /** Tiempo máximo TOTAL del envío (token incluido). Default 3000 ms. */
+  timeoutMs?: number;
+  /** Reemplaza `fetch` (tests). Default: el `fetch` global. */
+  fetch?: typeof fetch;
+}
+interface RecordAdClickOptions extends AdClickApiOptions {
+  /** Body JSON tal como lo mandó el navegador; se valida aquí. */
+  payload: unknown;
+  /** Usuario logueado, o null/omitido si no hay sesión. */
+  user?: AdClickUser | null;
+  /** Organización (whitelabel) del tenant, o null. */
+  org?: number | null;
+  ip?: string | null;
+  userAgent?: string | null;
+  /** Hora del click en el servidor. Default: ahora. */
+  clickedAt?: Date;
+}
+type RecordAdClickFailureReason =
+/** El body del navegador no cumple el contrato (`error` = ZodError). */
+"invalid_payload" |
+/** Falta `apiBase`, `clientId` o `clientSecret`. */
+"not_configured" |
+/** `POST /oauth/token` respondió con error (credenciales o scope). */
+"token_failed" |
+/** 401 aun con un token nuevo. */
+"unauthorized" |
+/** 403: el cliente no tiene el scope `ad-clicks:write`. */
+"forbidden" |
+/** 422: Laravel rechazó el body. */
+"rejected" |
+/** Otro status de error (5xx, 429…). */
+"http_error" | "timeout" | "network_error";
+interface RecordAdClickFailure {
+  ok: false;
+  reason: RecordAdClickFailureReason;
+  /** Status HTTP de la respuesta que falló, si hubo respuesta. */
+  httpStatus?: number;
+  error?: unknown;
+}
+type RecordAdClickResult = {
+  ok: true;
+  status: "recorded" | "duplicate";
+  httpStatus: number;
+} | RecordAdClickFailure;
+/**
+ * Registra un click en Laravel (bajo nivel; `createAdClickRoute` lo usa por dentro): valida el
+ * body del navegador, arma el body con usuario, organización, IP y user agent, y lo envía con un
+ * token client_credentials cacheado. Nunca lanza.
+ */
+export declare function recordAdClick(options: RecordAdClickOptions): Promise<RecordAdClickResult>;
+type MaybePromise<T> = T | Promise<T>;
+interface AdClickRouteErrorInfo {
+  /** Dónde falló: la sesión (`get_user`), el tenant (`get_org`) o el envío a Laravel (`record`). */
+  stage: "get_user" | "get_org" | "record";
+  click_id: string;
+  /** Solo en `record`: el resultado del envío. */
+  result?: RecordAdClickFailure;
+}
+interface AdClickRouteOptions extends AdClickApiOptions {
+  /**
+   * Usuario logueado desde la sesión del SITIO (cookie del mismo origen), o null si no hay
+   * sesión. Si lanza, el click se registra igual con `user: null` (y se avisa a `onError`).
+   */
+  getUser: (request: Request) => MaybePromise<AdClickUser | null | undefined>;
+  /** Organización (whitelabel) del tenant, o null. Si lanza, `org: null`. */
+  getOrg: (request: Request) => MaybePromise<number | null | undefined>;
+  /** IP del cliente. Default: `resolveClientIp(request.headers)`. */
+  getIp?: (request: Request) => string | null | undefined;
+  /**
+   * Errores que no llegan al navegador (siempre recibe 204): sesión, tenant y envío a Laravel.
+   * Nunca recibe datos del usuario.
+   */
+  onError?: (error: unknown, info: AdClickRouteErrorInfo) => void;
+  /**
+   * Para responder sin esperar a Laravel: recibe la promesa del envío y debe mantener viva la
+   * función hasta que termine (`after` de `next/server`, `waitUntil` de Vercel o del runtime
+   * edge). Sin esto, la ruta espera el envío (como máximo `timeoutMs`) antes de responder.
+   */
+  waitUntil?: (task: Promise<unknown>) => void;
+  /** Tamaño máximo del body. Default 8 KB. */
+  maxBodyBytes?: number;
+}
+/**
+ * Handler de la ruta del sitio que recibe el registro de clicks del SDK (`clickRecord`) y lo
+ * reenvía a Laravel con la identidad de la sesión. Para Next.js: `export const POST =
+ * createAdClickRoute({ … })`. Usa solo `Request`/`Response`/`fetch` estándar (Node ≥ 18, edge).
+ *
+ * Respuestas al navegador: 204 (registro aceptado, aunque Laravel falle: se avisa a `onError`),
+ * 400 body inválido, 403 request de otro sitio, 405 método distinto de POST, 413 body grande.
+ */
+export declare function createAdClickRoute(options: AdClickRouteOptions): (request: Request) => Promise<Response>;
+export type { AdClickApiOptions, AdClickRecordBody, AdClickRecordPayload, AdClickRouteErrorInfo, AdClickRouteOptions, AdClickUser, RecordAdClickFailure, RecordAdClickFailureReason, RecordAdClickOptions, RecordAdClickResult };

package/dist/server.js

@@ -0,0 +1,445 @@
+import { r as placement } from "./shared-D2s2QSYg.js";
+import { z } from "zod";
+// src/server/ip.ts
+const IP_HEADERS = [
+	"cf-connecting-ip",
+	"true-client-ip",
+	"x-forwarded-for",
+	"x-real-ip"
+];
+const PLACEHOLDERS = /* @__PURE__ */ new Set([
+	"0",
+	"0.0.0.0",
+	"::",
+	"::1",
+	"127.0.0.1",
+	"::ffff:127.0.0.1"
+]);
+const IPV4 = /^(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$/;
+const HEX_GROUP = /^[0-9a-f]{1,4}$/;
+function isIPv4(value) {
+	return IPV4.test(value);
+}
+function isIPv6(value) {
+	if (value.length > 45 || !value.includes(":")) return false;
+	let address = value;
+	const lastColon = address.lastIndexOf(":");
+	const tail = address.slice(lastColon + 1);
+	if (tail.includes(".")) {
+		if (!isIPv4(tail)) return false;
+		address = `${address.slice(0, lastColon + 1)}0:0`;
+	}
+	const halves = address.split("::");
+	if (halves.length > 2) return false;
+	const groups = (part) => part ? part.split(":") : [];
+	const head = groups(halves[0]);
+	const rest = groups(halves[1]);
+	if (![...head, ...rest].every((group) => HEX_GROUP.test(group))) return false;
+	const count = head.length + rest.length;
+	return halves.length === 2 ? count < 8 : count === 8;
+}
+/**
+* Normaliza un valor de header a una IP válida, o null. Acepta `[v6]:puerto` y `v4:puerto`
+* (algunos balanceadores agregan el puerto).
+*/
+function normalizeIp(raw) {
+	let value = raw.trim().toLowerCase();
+	const bracketed = /^\[([^\]]+)\](?::\d+)?$/.exec(value);
+	if (bracketed?.[1]) value = bracketed[1];
+	else if (/^[\d.]+:\d+$/.test(value)) value = value.slice(0, value.lastIndexOf(":"));
+	if (PLACEHOLDERS.has(value)) return null;
+	return isIPv4(value) || isIPv6(value) ? value : null;
+}
+/**
+* IP del cliente desde los headers del request: `cf-connecting-ip`, `true-client-ip`, el primer
+* valor de `x-forwarded-for` y `x-real-ip`, en ese orden. Salta los valores vacíos, inválidos o
+* de relleno (`0`, `::1`, `127.0.0.1`…). Devuelve null si ninguno sirve.
+*/
+function resolveClientIp(headers) {
+	for (const name of IP_HEADERS) {
+		const raw = headers.get(name);
+		if (!raw) continue;
+		const ip = normalizeIp(name === "x-forwarded-for" ? raw.split(",")[0] ?? "" : raw);
+		if (ip) return ip;
+	}
+	return null;
+}
+// src/server/record.ts
+/**
+* Body del navegador (`AdClickRecordPayload`). Los campos desconocidos se descartan: solo viaja a
+* Laravel lo que este esquema conoce.
+*/
+const adClickRecordPayloadSchema = z.object({
+	v: z.literal(1),
+	click_id: z.uuid(),
+	ad_id: z.string().min(1).max(100),
+	token: z.string().max(2e3).optional(),
+	placement,
+	position: z.int().nonnegative().optional(),
+	page_url: z.string().min(1).max(2e3).regex(/^https?:\/\//i, "page_url: URL http(s)"),
+	ts: z.iso.datetime({ offset: true })
+});
+const SCOPE = "ad-clicks:write";
+const DEFAULT_TIMEOUT_MS = 3e3;
+const MAX_USER_AGENT_LENGTH = 500;
+const DEFAULT_TOKEN_TTL_S = 3600;
+function parseAdClickPayload(input) {
+	return adClickRecordPayloadSchema.safeParse(input);
+}
+function text(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed === "" ? null : trimmed;
+}
+function normalizeUser(user) {
+	if (!user) return null;
+	return {
+		inspira_id: text(user.inspira_id),
+		email: text(user.email),
+		phone: text(user.phone),
+		external_id: text(user.external_id),
+		loyalty_id: text(user.loyalty_id)
+	};
+}
+/** Arma el body para Laravel con un payload ya validado y el contexto del servidor. */
+function buildAdClickBody(payload, context) {
+	const userAgent = text(context.userAgent)?.slice(0, MAX_USER_AGENT_LENGTH) ?? null;
+	return {
+		click_id: payload.click_id,
+		ad_id: payload.ad_id,
+		token: payload.token,
+		placement: payload.placement,
+		position: payload.position,
+		page_url: payload.page_url,
+		client_ts: payload.ts,
+		clicked_at: (context.clickedAt ?? /* @__PURE__ */ new Date()).toISOString(),
+		org: Number.isInteger(context.org) ? context.org : null,
+		ip: typeof context.ip === "string" ? normalizeIp(context.ip) : null,
+		user_agent: userAgent,
+		user: normalizeUser(context.user)
+	};
+}
+const tokens = /* @__PURE__ */ new Map();
+const pendingTokens = /* @__PURE__ */ new Map();
+var TokenError = class extends Error {
+	constructor(httpStatus) {
+		super(`oauth/token respondió ${httpStatus}`);
+		this.httpStatus = httpStatus;
+	}
+};
+const baseUrl = (apiBase) => apiBase.replace(/\/+$/, "");
+const cacheKey = (options) => `${baseUrl(options.apiBase)}\n${options.clientId}`;
+async function requestToken(options, doFetch, signal) {
+	const response = await doFetch(`${baseUrl(options.apiBase)}/oauth/token`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/x-www-form-urlencoded",
+			Accept: "application/json"
+		},
+		body: new URLSearchParams({
+			grant_type: "client_credentials",
+			client_id: options.clientId,
+			client_secret: options.clientSecret,
+			scope: SCOPE
+		}).toString(),
+		signal
+	});
+	if (!response.ok) {
+		await discard(response);
+		throw new TokenError(response.status);
+	}
+	const data = await response.json();
+	if (typeof data.access_token !== "string" || data.access_token === "") throw new TokenError(response.status);
+	const ttl = typeof data.expires_in === "number" && data.expires_in > 0 ? data.expires_in : DEFAULT_TOKEN_TTL_S;
+	const margin = Math.min(60, ttl / 10);
+	return {
+		token: data.access_token,
+		refreshAt: Date.now() + (ttl - margin) * 1e3
+	};
+}
+function untilAborted(promise, signal) {
+	if (signal.aborted) return Promise.reject(signal.reason);
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(signal.reason);
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+	});
+}
+async function accessToken(options, doFetch, signal) {
+	const key = cacheKey(options);
+	const cached = tokens.get(key);
+	if (cached && Date.now() < cached.refreshAt) return cached.token;
+	let pending = pendingTokens.get(key);
+	if (!pending) {
+		pending = requestToken(options, doFetch, signal).then((fresh) => {
+			tokens.set(key, fresh);
+			pendingTokens.delete(key);
+			return fresh;
+		}, (error) => {
+			pendingTokens.delete(key);
+			throw error;
+		});
+		pendingTokens.set(key, pending);
+	}
+	return (await untilAborted(pending, signal)).token;
+}
+function forgetToken(options, token) {
+	const key = cacheKey(options);
+	if (tokens.get(key)?.token === token) tokens.delete(key);
+}
+async function discard(response) {
+	try {
+		await response.text();
+	} catch {}
+}
+function failureFor(status) {
+	return {
+		ok: false,
+		reason: status === 401 ? "unauthorized" : status === 403 ? "forbidden" : status === 422 ? "rejected" : "http_error",
+		httpStatus: status
+	};
+}
+/**
+* Envía un body ya armado a `POST {apiBase}/api/v1/ad-clicks`. Pide (y cachea) el token; ante un
+* 401 lo renueva y reintenta una vez. Nunca lanza: los errores vuelven como `ok: false`.
+*/
+async function deliverAdClick(body, options) {
+	if (!options.apiBase || !options.clientId || !options.clientSecret) return {
+		ok: false,
+		reason: "not_configured"
+	};
+	const doFetch = options.fetch ?? globalThis.fetch;
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(/* @__PURE__ */ new Error("ad click record: timeout")), options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+	try {
+		for (let attempt = 1;; attempt++) {
+			const token = await accessToken(options, doFetch, controller.signal);
+			const response = await doFetch(`${baseUrl(options.apiBase)}/api/v1/ad-clicks`, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${token}`,
+					"Content-Type": "application/json",
+					Accept: "application/json"
+				},
+				body: JSON.stringify(body),
+				signal: controller.signal
+			});
+			if (response.status === 401 && attempt === 1) {
+				await discard(response);
+				forgetToken(options, token);
+				continue;
+			}
+			if (!response.ok) {
+				await discard(response);
+				return failureFor(response.status);
+			}
+			let status;
+			try {
+				status = (await response.json())?.status;
+			} catch {
+				status = void 0;
+			}
+			return {
+				ok: true,
+				status: status === "duplicate" || status !== "recorded" && response.status === 200 ? "duplicate" : "recorded",
+				httpStatus: response.status
+			};
+		}
+	} catch (error) {
+		if (controller.signal.aborted) return {
+			ok: false,
+			reason: "timeout",
+			error
+		};
+		if (error instanceof TokenError) return {
+			ok: false,
+			reason: "token_failed",
+			httpStatus: error.httpStatus,
+			error
+		};
+		return {
+			ok: false,
+			reason: "network_error",
+			error
+		};
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* Registra un click en Laravel (bajo nivel; `createAdClickRoute` lo usa por dentro): valida el
+* body del navegador, arma el body con usuario, organización, IP y user agent, y lo envía con un
+* token client_credentials cacheado. Nunca lanza.
+*/
+async function recordAdClick(options) {
+	try {
+		const parsed = parseAdClickPayload(options.payload);
+		if (!parsed.success) return {
+			ok: false,
+			reason: "invalid_payload",
+			error: parsed.error
+		};
+		return await deliverAdClick(buildAdClickBody(parsed.data, options), options);
+	} catch (error) {
+		return {
+			ok: false,
+			reason: "network_error",
+			error
+		};
+	}
+}
+// src/server/route.ts
+const DEFAULT_MAX_BODY_BYTES = 8192;
+const NO_STORE = { "Cache-Control": "no-store" };
+function reply(status, error, headers = {}) {
+	if (!error) return new Response(null, {
+		status,
+		headers: {
+			...NO_STORE,
+			...headers
+		}
+	});
+	return new Response(JSON.stringify({ error }), {
+		status,
+		headers: {
+			...NO_STORE,
+			"Content-Type": "application/json",
+			...headers
+		}
+	});
+}
+const firstValue = (value) => value?.split(",")[0]?.trim().toLowerCase() || null;
+function requestHosts(request) {
+	const hosts = [firstValue(request.headers.get("host"))];
+	hosts.push(firstValue(request.headers.get("x-forwarded-host")));
+	try {
+		hosts.push(new URL(request.url).host.toLowerCase());
+	} catch {}
+	return hosts.filter((host) => !!host);
+}
+/**
+* Solo requests del propio sitio: la ruta usa la cookie de sesión, así que un POST desde otro
+* sitio (CSRF) registraría clicks a nombre del visitante.
+* - Con `Sec-Fetch-Site` (navegadores actuales; el navegador lo calcula y una página no lo puede
+*   falsear) solo se acepta `same-origin`.
+* - Sin él, el `Origin` (si viene) debe tener el mismo host que el request. Sin ninguno de los dos
+*   no es un navegador actual: no hay cookie de un visitante que proteger.
+*/
+function isSameOrigin(request) {
+	const site = request.headers.get("sec-fetch-site");
+	if (site !== null) return site === "same-origin";
+	const origin = request.headers.get("origin");
+	if (origin === null) return true;
+	let host;
+	try {
+		host = new URL(origin).host.toLowerCase();
+	} catch {
+		return false;
+	}
+	return host !== "" && requestHosts(request).includes(host);
+}
+var BodyTooLarge = class extends Error {};
+async function readBody(request, max) {
+	const declared = Number(request.headers.get("content-length") ?? "");
+	if (Number.isFinite(declared) && declared > max) throw new BodyTooLarge();
+	if (!request.body) return "";
+	const reader = request.body.getReader();
+	const chunks = [];
+	let size = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		size += value.byteLength;
+		if (size > max) {
+			reader.cancel().catch(() => {});
+			throw new BodyTooLarge();
+		}
+		chunks.push(value);
+	}
+	const bytes = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return new TextDecoder().decode(bytes);
+}
+/**
+* Handler de la ruta del sitio que recibe el registro de clicks del SDK (`clickRecord`) y lo
+* reenvía a Laravel con la identidad de la sesión. Para Next.js: `export const POST =
+* createAdClickRoute({ … })`. Usa solo `Request`/`Response`/`fetch` estándar (Node ≥ 18, edge).
+*
+* Respuestas al navegador: 204 (registro aceptado, aunque Laravel falle: se avisa a `onError`),
+* 400 body inválido, 403 request de otro sitio, 405 método distinto de POST, 413 body grande.
+*/
+function createAdClickRoute(options) {
+	const maxBodyBytes = options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
+	const report = (error, info) => {
+		try {
+			options.onError?.(error, info);
+		} catch {}
+	};
+	return async function adClickRoute(request) {
+		if (request.method !== "POST") return reply(405, void 0, { Allow: "POST" });
+		if (!isSameOrigin(request)) return reply(403, "cross_site");
+		let input;
+		try {
+			input = JSON.parse(await readBody(request, maxBodyBytes));
+		} catch (error) {
+			if (error instanceof BodyTooLarge) return reply(413, "payload_too_large");
+			return reply(400, "invalid_payload");
+		}
+		const parsed = parseAdClickPayload(input);
+		if (!parsed.success) return reply(400, "invalid_payload");
+		const payload = parsed.data;
+		const clickId = payload.click_id;
+		let user = null;
+		try {
+			user = await options.getUser(request) ?? null;
+		} catch (error) {
+			report(error, {
+				stage: "get_user",
+				click_id: clickId
+			});
+		}
+		let org = null;
+		try {
+			org = await options.getOrg(request) ?? null;
+		} catch (error) {
+			report(error, {
+				stage: "get_org",
+				click_id: clickId
+			});
+		}
+		let ip = null;
+		try {
+			ip = options.getIp ? options.getIp(request) ?? null : resolveClientIp(request.headers);
+		} catch {
+			ip = null;
+		}
+		const task = deliverAdClick(buildAdClickBody(payload, {
+			user,
+			org,
+			ip,
+			userAgent: request.headers.get("user-agent")
+		}), options).then((result) => {
+			if (!result.ok) {
+				const error = result.error ?? /* @__PURE__ */ new Error(`ad click record: ${result.reason}`);
+				report(error, {
+					stage: "record",
+					click_id: clickId,
+					result
+				});
+			}
+		});
+		if (options.waitUntil) try {
+			options.waitUntil(task);
+		} catch {
+			await task;
+		}
+		else await task;
+		return reply(204);
+	};
+}
+export { createAdClickRoute, recordAdClick, resolveClientIp };

package/dist/shared-D2s2QSYg.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+// src/catalog/shared.ts
+/**
+* Dónde se mostró algo, como `<página>.<sección>` en minúsculas: `home.resorts-carousel`,
+* `hotels-srp.side-rail`, `landing-ufc.hero`. Es la dimensión principal de los reportes:
+* mantenla estable (no metas ids ni textos traducidos).
+*/
+const placement = z.string().max(100).regex(/^[a-z0-9_-]+(\.[a-z0-9_-]+)*$/, "placement: <pagina>.<seccion> en minúsculas").describe("Dónde se mostró: <pagina>.<seccion>, p. ej. home.resorts-carousel");
+/** Posición 0-based dentro de un carrusel/lista. */
+const position = z.int().nonnegative().describe("Posición 0-based en la lista o carrusel");
+const itemId = z.string().min(1).max(200);
+/** Servicios de búsqueda/reserva de la plataforma. */
+const service = z.enum([
+	"hotels",
+	"resorts",
+	"flights",
+	"cars",
+	"activities",
+	"transfers",
+	"cruises"
+]).describe("Servicio de la plataforma");
+const currency = z.string().regex(/^[A-Z]{3}$/, "currency: código ISO 4217 en mayúsculas").describe("Código ISO 4217, p. ej. USD");
+export { service as a, position as i, itemId as n, placement as r, currency as t };

package/dist/version-DPt-j93d.js

@@ -0,0 +1,4 @@
+// src/version.ts
+const SDK_NAME = "@inspira-npm/events";
+const SDK_VERSION = "0.3.0";
+export { SDK_VERSION as n, SDK_NAME as t };

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "@inspira-npm/events",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0",
+  "description": "SDK de tracking de eventos de Inspira (ads, cards, mapas, búsquedas) para navegador, con helpers de servidor en /server.",
+  "license": "UNLICENSED",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./catalog": {
+      "types": "./dist/catalog.d.ts",
+      "import": "./dist/catalog.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./catalog.json": "./dist/catalog.json",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsdown && node scripts/build-catalog.mjs && node scripts/build-catalog-docs.mjs",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build"
+  },
+  "dependencies": {
+    "zod": "^4.6.7"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.