@theelena/sdk 0.1.0 → 0.1.2

package/dist/index.js

@@ -0,0 +1,1766 @@
+// src/errors.ts
+var ElenaApiError = class extends Error {
+  status;
+  code;
+  details;
+  retryAfter;
+  constructor(message, details) {
+    super(message);
+    this.name = "ElenaApiError";
+    this.status = details.status;
+    this.code = details.code;
+    this.details = details.details;
+    this.retryAfter = details.retryAfter;
+  }
+};
+var ElenaNetworkError = class extends Error {
+  constructor(message = "Error de red desconocido") {
+    super(message);
+    this.name = "ElenaNetworkError";
+  }
+};
+var ElenaTimeoutError = class extends Error {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`Elena no respondi\xF3 en ${timeoutMs} ms.`);
+    this.name = "ElenaTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var ElenaRequestAbortedError = class extends Error {
+  constructor(message = "La solicitud a Elena fue cancelada.") {
+    super(message);
+    this.name = "ElenaRequestAbortedError";
+  }
+};
+var ElenaResponseError = class extends Error {
+  status;
+  bodyText;
+  constructor(message, details) {
+    super(message);
+    this.name = "ElenaResponseError";
+    this.status = details.status;
+    this.bodyText = details.bodyText;
+  }
+};
+var ElenaCheckoutValidationError = class extends Error {
+  code;
+  /** Selection path, e.g. selections[0].quantity or selections[0].selectedOptions. */
+  field;
+  constructor(message, details) {
+    super(message);
+    this.name = "ElenaCheckoutValidationError";
+    this.code = details.code;
+    this.field = details.field;
+  }
+};
+
+// src/resources/orders.ts
+var AccessResource = class {
+  constructor(http, businessSlug) {
+    this.http = http;
+    this.businessSlug = businessSlug;
+  }
+  http;
+  businessSlug;
+  resolve(publicKey) {
+    return this.http.request(
+      `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}/access/${encodeURIComponent(publicKey)}`
+    );
+  }
+  createOrder(publicKey, input, options = {}) {
+    const body = options.idempotencyKey && !input.idempotencyKey ? { ...input, idempotencyKey: options.idempotencyKey } : input;
+    return this.http.request(
+      `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}/access/${encodeURIComponent(publicKey)}/orders`,
+      { method: "POST", body, signal: options.signal }
+    );
+  }
+};
+var OrdersResource = class {
+  constructor(http, businessSlug) {
+    this.http = http;
+    this.businessSlug = businessSlug;
+  }
+  http;
+  businessSlug;
+  create(input, options = {}) {
+    const body = options.idempotencyKey && !input.idempotencyKey ? { ...input, idempotencyKey: options.idempotencyKey } : input;
+    return this.http.request(
+      `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}/orders`,
+      { method: "POST", body, signal: options.signal }
+    );
+  }
+  async getById(orderId) {
+    if (!this.http.visitorId) {
+      throw new ElenaApiError("Consultar un pedido requiere visitorId.", { status: 0 });
+    }
+    return this.http.request(
+      `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}/orders/${encodeURIComponent(orderId)}`
+    );
+  }
+  getTracking(trackingToken) {
+    return this.http.request(
+      `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}/tracking/${encodeURIComponent(trackingToken)}`
+    );
+  }
+  submitPaymentClaim(trackingToken, input) {
+    const form = new FormData();
+    form.set("referenceNumber", input.referenceNumber);
+    if (input.proofImage) form.set("proofImage", input.proofImage);
+    return this.http.request(
+      `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}/tracking/${encodeURIComponent(trackingToken)}/payment-claims`,
+      { method: "POST", body: form }
+    );
+  }
+};
+
+// src/resources/catalog.ts
+var CatalogResource = class {
+  constructor(http, businessSlug) {
+    this.http = http;
+    this.businessSlug = businessSlug;
+  }
+  http;
+  businessSlug;
+  getInfo() {
+    return this.http.request(
+      `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}`
+    );
+  }
+  getMenu(query) {
+    return this.http.request(
+      `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}/menu`,
+      { query: { search: query?.search } }
+    );
+  }
+  listHeroSlides() {
+    return this.http.request(
+      `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}/hero-slides`
+    );
+  }
+};
+var TablesResource = class {
+  constructor(http, businessSlug) {
+    this.http = http;
+    this.businessSlug = businessSlug;
+  }
+  http;
+  businessSlug;
+  listAvailable() {
+    return this.http.request(
+      `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}/tables/available`
+    );
+  }
+  get(tableId) {
+    return this.http.request(
+      `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}/tables/${encodeURIComponent(tableId)}`
+    );
+  }
+};
+
+// src/resources/realtime.ts
+var RealtimeResource = class {
+  constructor(http, businessSlug) {
+    this.http = http;
+    this.businessSlug = businessSlug;
+  }
+  http;
+  businessSlug;
+  /** SSE stream URL. EventSource-compatible: identity travels in query, not headers. */
+  getConnection(visitorId) {
+    const resolvedVisitorId = visitorId ?? this.http.visitorId;
+    if (!resolvedVisitorId) {
+      throw new ElenaApiError("El stream de eventos requiere visitorId.", { status: 0 });
+    }
+    return {
+      url: this.http.url("/api/v1/public/events/stream", {
+        visitorId: resolvedVisitorId,
+        restaurantSlug: this.businessSlug
+      })
+    };
+  }
+};
+var ChatResource = class {
+  constructor(http, businessSlug) {
+    this.http = http;
+    this.businessSlug = businessSlug;
+  }
+  http;
+  businessSlug;
+  /** Connection descriptor for the existing Tari chat runtime. No HTTP call. */
+  getConnection() {
+    return {
+      apiUrl: this.http.url("/api/v1"),
+      businessSlug: this.businessSlug,
+      ...this.http.visitorId ? { visitorId: this.http.visitorId } : {}
+    };
+  }
+};
+var ContinuationsResource = class {
+  constructor(http, businessSlug) {
+    this.http = http;
+    this.businessSlug = businessSlug;
+  }
+  http;
+  businessSlug;
+  exchange(token) {
+    return this.http.request(
+      `/api/v1/public/journeys/${encodeURIComponent(this.businessSlug)}/exchange`,
+      { method: "POST", body: { token } }
+    );
+  }
+};
+var JourneyConflictError = class extends ElenaApiError {
+  journey;
+  constructor(journey) {
+    super("La journey cambi\xF3 en el servidor; recarga el estado.", {
+      status: 409,
+      code: "journey_conflict",
+      details: { journey }
+    });
+    this.name = "JourneyConflictError";
+    this.journey = journey;
+  }
+};
+var JourneyResource = class _JourneyResource {
+  constructor(http, businessSlug) {
+    this.http = http;
+    this.businessSlug = businessSlug;
+  }
+  http;
+  businessSlug;
+  getState() {
+    return this.http.request(
+      `/api/v1/public/journeys/${encodeURIComponent(this.businessSlug)}/state`
+    );
+  }
+  async dispatch(input) {
+    try {
+      return await this.http.request(
+        `/api/v1/public/journeys/${encodeURIComponent(this.businessSlug)}/events`,
+        {
+          method: "POST",
+          body: {
+            eventId: input.eventId,
+            expectedVersion: input.expectedVersion,
+            event: input.event
+          }
+        }
+      );
+    } catch (error) {
+      throw _JourneyResource.withConflict(error);
+    }
+  }
+  async confirm(input) {
+    try {
+      return await this.http.request(`/api/v1/public/journeys/${encodeURIComponent(this.businessSlug)}/confirm`, {
+        method: "POST",
+        body: {
+          eventId: input.eventId,
+          expectedVersion: input.expectedVersion,
+          fingerprint: input.fingerprint
+        }
+      });
+    } catch (error) {
+      throw _JourneyResource.withConflict(error);
+    }
+  }
+  static withConflict(error) {
+    if (error instanceof ElenaApiError && error.status === 409 && typeof error.details === "object" && error.details !== null && "journey" in error.details) {
+      const journey = error.details.journey;
+      return new JourneyConflictError(journey);
+    }
+    return error;
+  }
+};
+
+// src/resources/receipts.ts
+var ReceiptsResource = class {
+  constructor(http, businessSlug) {
+    this.http = http;
+    this.businessSlug = businessSlug;
+  }
+  http;
+  businessSlug;
+  async get(receiptToken) {
+    const receipt = await this.http.request(
+      `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}/sales/${encodeURIComponent(receiptToken)}`
+    );
+    const url = receipt.receipt?.url;
+    if (!url || !url.startsWith("/")) return receipt;
+    if (!receipt.receipt) return receipt;
+    return { ...receipt, receipt: { ...receipt.receipt, url: this.http.url(url) } };
+  }
+  /** PDF endpoint answers 302; callers open/download the URL, never JSON-fetch it. */
+  getPdfUrl(receiptToken) {
+    return this.http.url(
+      `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}/sales/${encodeURIComponent(receiptToken)}/pdf`
+    );
+  }
+};
+var PresenceResource = class {
+  constructor(http, businessSlug) {
+    this.http = http;
+    this.businessSlug = businessSlug;
+  }
+  http;
+  businessSlug;
+  report(input, options = {}) {
+    return this.http.request(
+      `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}/live-session`,
+      { method: "POST", body: input, signal: options.signal }
+    );
+  }
+  /** Beacon payload for pagehide/unload, where fetch cannot be awaited. */
+  getBeaconRequest(input) {
+    return {
+      url: this.http.url(
+        `/api/v1/public/catalog/${encodeURIComponent(this.businessSlug)}/live-session`
+      ),
+      body: new Blob([JSON.stringify(input)], { type: "application/json" })
+    };
+  }
+};
+
+// src/resources/discovery.ts
+var EventsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  get(businessSlug, eventSlug) {
+    return this.http.request("/api/v1/public/events/detail", {
+      query: { restaurantSlug: businessSlug, eventSlug }
+    });
+  }
+};
+var TicketsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  emit(input) {
+    return this.http.request("/api/v1/public/tickets/emissions", {
+      method: "POST",
+      body: input
+    });
+  }
+  getStatus(token) {
+    return this.http.request(`/api/v1/public/tickets/${encodeURIComponent(token)}`);
+  }
+};
+var AssetsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Render endpoint serves binary content; callers use the URL, never JSON-fetch it. */
+  getRenderUrl(assetId) {
+    return this.http.url(`/api/v1/public/assets/${encodeURIComponent(assetId)}/render`);
+  }
+};
+
+// src/business.ts
+var BusinessScope = class {
+  constructor(http, slug) {
+    this.http = http;
+    const normalized = slug.trim();
+    if (!normalized) {
+      throw new TypeError("BusinessScope necesita un slug.");
+    }
+    this.slug = normalized;
+    this.catalog = new CatalogResource(http, normalized);
+    this.tables = new TablesResource(http, normalized);
+    this.access = new AccessResource(http, normalized);
+    this.orders = new OrdersResource(http, normalized);
+    this.receipts = new ReceiptsResource(http, normalized);
+    this.presence = new PresenceResource(http, normalized);
+    this.continuations = new ContinuationsResource(http, normalized);
+    this.realtime = new RealtimeResource(http, normalized);
+    this.chat = new ChatResource(http, normalized);
+    this.eventsResource = new EventsResource(http);
+    this.ticketsResource = new TicketsResource(http);
+  }
+  http;
+  slug;
+  catalog;
+  tables;
+  access;
+  orders;
+  receipts;
+  presence;
+  continuations;
+  realtime;
+  chat;
+  eventsResource;
+  ticketsResource;
+  getInfo() {
+    return this.catalog.getInfo();
+  }
+  getEvent(eventSlug) {
+    return this.eventsResource.get(this.slug, eventSlug);
+  }
+  emitTickets(input) {
+    return this.ticketsResource.emit({ ...input, restaurantSlug: this.slug });
+  }
+};
+
+// src/http-client.ts
+var DEFAULT_TIMEOUT_MS = 15e3;
+function isFormDataBody(body) {
+  return typeof FormData !== "undefined" && body instanceof FormData;
+}
+function isPlainJsonBody(body) {
+  if (body === null || body === void 0) return false;
+  if (typeof body !== "object") return false;
+  if (isFormDataBody(body)) return false;
+  if (body instanceof Blob) return false;
+  if (body instanceof ArrayBuffer) return false;
+  if (ArrayBuffer.isView(body)) return false;
+  if (body instanceof URLSearchParams) return false;
+  return true;
+}
+var ElenaHttpClient = class {
+  baseUrl;
+  visitorId;
+  fetchImpl;
+  timeoutMs;
+  accessToken;
+  constructor(options, accessToken) {
+    const normalizedBaseUrl = options.baseUrl.trim().replace(/\/+$/, "");
+    if (!normalizedBaseUrl) {
+      throw new TypeError("Elena SDK necesita un baseUrl.");
+    }
+    try {
+      const base = new URL(normalizedBaseUrl);
+      if (!/^https?:\/\//i.test(normalizedBaseUrl) || /[?#\\\s]/.test(normalizedBaseUrl) || base.username || base.password) {
+        throw new TypeError();
+      }
+    } catch {
+      throw new TypeError(
+        "El baseUrl de Elena debe ser una URL HTTP(S) sin credenciales, query ni fragmento."
+      );
+    }
+    this.baseUrl = normalizedBaseUrl;
+    const visitorId = options.visitorId?.trim();
+    this.visitorId = visitorId ? visitorId : void 0;
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      throw new TypeError("Elena SDK necesita una implementaci\xF3n de fetch.");
+    }
+    this.fetchImpl = fetchImpl.bind(globalThis);
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      throw new TypeError("El timeout del SDK de Elena debe ser mayor que cero.");
+    }
+    this.timeoutMs = timeoutMs;
+    const token = accessToken?.trim();
+    this.accessToken = token ? token : void 0;
+  }
+  url(path, query) {
+    if (/^[a-z][a-z\d+.-]*:/i.test(path) || path.startsWith("//") || // eslint-disable-next-line no-control-regex -- Intentional: reject control chars and whitespace in paths.
+    /[\\\s\u0000-\u001f\u007f]/.test(path) || path.split(/[/?#]/).some((segment) => /^(?:\.|%2e){1,2}$/i.test(segment))) {
+      throw new TypeError(
+        "Las rutas del SDK de Elena deben ser relativas al baseUrl y no escapar de \xE9l."
+      );
+    }
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const url = `${this.baseUrl}${normalizedPath}`;
+    if (!query) return url;
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+      if (value === void 0) continue;
+      params.set(key, String(value));
+    }
+    const qs = params.toString();
+    return qs ? `${url}?${qs}` : url;
+  }
+  async request(path, options = {}) {
+    if (options.signal?.aborted) {
+      throw new ElenaRequestAbortedError();
+    }
+    const headers = new Headers();
+    headers.set("Accept", "application/json");
+    let body;
+    if (options.body !== void 0) {
+      if (isPlainJsonBody(options.body)) {
+        headers.set("Content-Type", "application/json");
+        body = JSON.stringify(options.body);
+      } else {
+        body = options.body;
+      }
+    }
+    if (this.visitorId) headers.set("x-visitor-id", this.visitorId);
+    if (options.headers) {
+      new Headers(options.headers).forEach((value, key) => {
+        headers.set(key, value);
+      });
+    }
+    if (this.accessToken) headers.set("Authorization", `Bearer ${this.accessToken}`);
+    const controller = new AbortController();
+    let timedOut = false;
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, this.timeoutMs);
+    const onCallerAbort = () => {
+      controller.abort();
+    };
+    options.signal?.addEventListener("abort", onCallerAbort, { once: true });
+    if (options.signal?.aborted) onCallerAbort();
+    const bounded = (promise) => new Promise((resolve, reject) => {
+      const onAbort = () => {
+        cleanup();
+        reject(timedOut ? new ElenaTimeoutError(this.timeoutMs) : new ElenaRequestAbortedError());
+      };
+      const cleanup = () => controller.signal.removeEventListener("abort", onAbort);
+      controller.signal.addEventListener("abort", onAbort, { once: true });
+      promise.then(
+        (value) => {
+          cleanup();
+          resolve(value);
+        },
+        (error) => {
+          cleanup();
+          reject(error);
+        }
+      );
+      if (controller.signal.aborted) onAbort();
+    });
+    let response;
+    let text;
+    try {
+      response = await bounded(
+        Promise.resolve().then(() => {
+          if (controller.signal.aborted) throw new ElenaRequestAbortedError();
+          return this.fetchImpl(this.url(path, options.query), {
+            method: options.method ?? "GET",
+            headers,
+            body,
+            credentials: "omit",
+            redirect: "error",
+            referrerPolicy: "no-referrer",
+            signal: controller.signal,
+            ...options.keepalive ? { keepalive: true } : {}
+          });
+        })
+      );
+      if (response.redirected || response.status >= 300 && response.status < 400 || response.type === "opaqueredirect" || response.url && new URL(response.url).origin !== new URL(this.baseUrl).origin) {
+        throw new ElenaResponseError("El SDK de Elena no sigue redirecciones de la API.", {
+          status: response.status
+        });
+      }
+      text = await bounded(Promise.resolve().then(() => response.text()));
+    } catch (error) {
+      if (timedOut) throw new ElenaTimeoutError(this.timeoutMs);
+      if (options.signal?.aborted) throw new ElenaRequestAbortedError();
+      if (error instanceof ElenaResponseError) throw error;
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new ElenaRequestAbortedError();
+      }
+      throw new ElenaNetworkError(error instanceof Error ? error.message : void 0);
+    } finally {
+      clearTimeout(timeout);
+      options.signal?.removeEventListener("abort", onCallerAbort);
+    }
+    const retryAfter = response.headers.get("retry-after") ?? void 0;
+    let payload = null;
+    if (text) {
+      try {
+        payload = JSON.parse(text);
+      } catch {
+        if (!response.ok) {
+          throw new ElenaApiError(`Elena respondi\xF3 ${response.status}: ${response.statusText}`, {
+            status: response.status,
+            details: text,
+            retryAfter
+          });
+        }
+        throw new ElenaResponseError("Respuesta inv\xE1lida del servidor de Elena.", {
+          status: response.status,
+          bodyText: text
+        });
+      }
+    }
+    if (!response.ok) {
+      let code;
+      let message;
+      if (typeof payload === "object" && payload !== null) {
+        if ("code" in payload && typeof payload.code === "string" && payload.code) {
+          code = payload.code;
+        } else if ("error" in payload && typeof payload.error === "string" && payload.error) {
+          code = payload.error;
+        }
+        if (!code && "details" in payload && typeof payload.details === "object" && payload.details !== null && "code" in payload.details && typeof payload.details.code === "string" && payload.details.code) {
+          code = payload.details.code;
+        }
+        if ("message" in payload && typeof payload.message === "string" && payload.message) {
+          message = payload.message;
+        }
+      }
+      throw new ElenaApiError(
+        message ?? `Elena respondi\xF3 ${response.status}: ${response.statusText}`,
+        { status: response.status, code, details: payload, retryAfter }
+      );
+    }
+    return payload;
+  }
+};
+
+// src/client.ts
+function createElenaPublicClient(options) {
+  const http = new ElenaHttpClient(options);
+  return {
+    business: (slug) => new BusinessScope(http, slug),
+    tickets: new TicketsResource(http),
+    assets: new AssetsResource(http)
+  };
+}
+function createElenaJourneyClient(options) {
+  if (!options.accessToken?.trim()) {
+    throw new TypeError("El cliente journey de Elena necesita un accessToken.");
+  }
+  const businessSlug = options.businessSlug.trim();
+  if (!businessSlug) {
+    throw new TypeError("El cliente journey de Elena necesita un businessSlug.");
+  }
+  const http = new ElenaHttpClient(
+    {
+      baseUrl: options.baseUrl,
+      fetch: options.fetch,
+      timeoutMs: options.timeoutMs
+    },
+    options.accessToken
+  );
+  return { businessSlug, journeys: new JourneyResource(http, businessSlug) };
+}
+
+// src/checkout.ts
+var catalogName = (name) => name.trim().toLocaleLowerCase();
+function invalid(code, field, message) {
+  throw new ElenaCheckoutValidationError(message, { code, field });
+}
+function buildOrderItems(menu, selections) {
+  return selections.map((selection, itemIndex) => {
+    const field = `selections[${itemIndex}]`;
+    const products = menu.products.filter((product2) => product2.id === selection.productId);
+    const product = products[0];
+    if (!product) {
+      return invalid(
+        "PRODUCT_NOT_FOUND",
+        `${field}.productId`,
+        "El producto no existe en el cat\xE1logo."
+      );
+    }
+    if (products.length !== 1) {
+      return invalid("AMBIGUOUS_SELECTION", `${field}.productId`, "El ID del producto es ambiguo.");
+    }
+    if (!product.available) {
+      return invalid(
+        "PRODUCT_UNAVAILABLE",
+        `${field}.productId`,
+        "El producto no est\xE1 disponible."
+      );
+    }
+    if (!Number.isInteger(selection.quantity) || selection.quantity < 1 || selection.quantity > 100) {
+      return invalid(
+        "INVALID_QUANTITY",
+        `${field}.quantity`,
+        "La cantidad debe ser un entero entre 1 y 100."
+      );
+    }
+    const counts = /* @__PURE__ */ new Map();
+    const selected = /* @__PURE__ */ new Map();
+    const extras = (selection.selectedOptions ?? []).map((selectionOption, optionIndex) => {
+      const optionField = `${field}.selectedOptions[${optionIndex}]`;
+      const groups = product.customizationGroups.filter(
+        (group2) => group2.id === selectionOption.groupId
+      );
+      const group = groups[0];
+      if (!group) {
+        return invalid(
+          "UNKNOWN_GROUP",
+          `${optionField}.groupId`,
+          "El grupo no pertenece al producto."
+        );
+      }
+      if (groups.length !== 1 || !catalogName(group.name) || product.customizationGroups.filter(
+        (candidate) => catalogName(candidate.name) === catalogName(group.name)
+      ).length !== 1) {
+        return invalid(
+          "AMBIGUOUS_SELECTION",
+          `${optionField}.groupId`,
+          "El nombre o ID del grupo es ambiguo."
+        );
+      }
+      const options = group.options.filter((option2) => option2.id === selectionOption.optionId);
+      const option = options[0];
+      if (!option) {
+        return invalid(
+          "UNKNOWN_OPTION",
+          `${optionField}.optionId`,
+          "La opci\xF3n no pertenece al grupo."
+        );
+      }
+      if (options.length !== 1 || !catalogName(option.name) || group.options.filter(
+        (candidate) => catalogName(candidate.name) === catalogName(option.name)
+      ).length !== 1) {
+        return invalid(
+          "AMBIGUOUS_SELECTION",
+          `${optionField}.optionId`,
+          "El nombre o ID de la opci\xF3n es ambiguo."
+        );
+      }
+      const groupSelections = selected.get(group.id) ?? /* @__PURE__ */ new Set();
+      if (groupSelections.has(option.id)) {
+        return invalid(
+          "DUPLICATE_OPTION",
+          `${optionField}.optionId`,
+          "Una opci\xF3n no puede seleccionarse m\xE1s de una vez por art\xEDculo."
+        );
+      }
+      groupSelections.add(option.id);
+      selected.set(group.id, groupSelections);
+      counts.set(group.id, (counts.get(group.id) ?? 0) + 1);
+      return {
+        groupName: group.name,
+        optionName: option.name,
+        additionalPrice: option.additionalPrice
+      };
+    });
+    for (const group of product.customizationGroups) {
+      const count = counts.get(group.id) ?? 0;
+      if (group.required && count === 0) {
+        return invalid(
+          "REQUIRED_OPTIONS",
+          `${field}.selectedOptions`,
+          `El grupo "${group.name}" requiere una opci\xF3n.`
+        );
+      }
+      if (count < group.minSelections) {
+        return invalid(
+          "MIN_SELECTIONS",
+          `${field}.selectedOptions`,
+          `El grupo "${group.name}" requiere al menos ${group.minSelections} opci\xF3n(es).`
+        );
+      }
+      if (count > group.maxSelections) {
+        return invalid(
+          "MAX_SELECTIONS",
+          `${field}.selectedOptions`,
+          `El grupo "${group.name}" permite como m\xE1ximo ${group.maxSelections} opci\xF3n(es).`
+        );
+      }
+    }
+    return {
+      productId: product.id,
+      cantidad: selection.quantity,
+      unitPrice: product.basePrice,
+      ...selection.notes !== void 0 ? { specialNotes: selection.notes } : {},
+      ...extras.length ? { extras } : {}
+    };
+  });
+}
+
+// ../shared/src/agent-contracts/access.ts
+import { z as z2 } from "zod";
+
+// ../shared/src/agent-contracts/common.ts
+import { z } from "zod";
+var ELENA_AGENT_CONTRACT_VERSION = "1";
+var elenaAgentVersionSchema = z.literal(ELENA_AGENT_CONTRACT_VERSION);
+var elenaAgentIdSchema = z.uuid();
+var elenaAgentRevisionSchema = z.number().int().min(1).max(Number.MAX_SAFE_INTEGER);
+var elenaAgentTimestampSchema = z.iso.datetime();
+var elenaAgentHashSchema = z.string().regex(/^[a-f0-9]{64}$/);
+var elenaAgentRefSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,99}$/);
+var elenaAgentNameSchema = z.string().trim().min(1).max(160);
+var elenaAgentTextSchema = z.string().trim().min(1).max(2e3);
+var elenaAgentCurrencySchema = z.literal("PEN");
+var elenaAgentNonnegativeMoneySchema = z.string().regex(/^(0|[1-9]\d{0,7})\.\d{2}$/);
+var elenaAgentMoneySchema = elenaAgentNonnegativeMoneySchema.refine(
+  (value) => value !== "0.00",
+  "Product price must be greater than zero"
+);
+var ELENA_AGENT_LIMITS = Object.freeze({
+  categoriesPerImport: 50,
+  productsPerImport: 200,
+  changesPerOperation: 200,
+  publicationProducts: 200,
+  galleryImages: 8,
+  extraGroups: 10,
+  optionsPerGroup: 30,
+  jsonBytes: 1024 * 1024,
+  mediaBytes: 10 * 1024 * 1024,
+  stagedBytesPerRestaurant: 100 * 1024 * 1024,
+  stagedFilesPerRestaurant: 20,
+  openOperationsPerRestaurant: 20,
+  openPreviewsPerRestaurant: 20,
+  activeKeysPerFamily: 10,
+  keyDefaultTtlSeconds: 30 * 24 * 60 * 60,
+  keyMaxTtlSeconds: 90 * 24 * 60 * 60,
+  pairingTtlSeconds: 600,
+  pairingPollSeconds: 5,
+  proposalTtlSeconds: 24 * 60 * 60,
+  previewTtlSeconds: 24 * 60 * 60,
+  stagingTtlSeconds: 48 * 60 * 60,
+  applyWindowSeconds: 60 * 60,
+  workerLeaseSeconds: 30,
+  workerHeartbeatSeconds: 10,
+  maxWorkerAttempts: 5,
+  resultRetentionDays: 90,
+  pageSize: 100
+});
+var elenaAgentErrorCodeSchema = z.enum([
+  "INVALID_REQUEST",
+  "UNSUPPORTED_VERSION",
+  "CREDENTIAL_REQUIRED",
+  "CREDENTIAL_INVALID",
+  "CREDENTIAL_EXPIRED",
+  "CREDENTIAL_REVOKED",
+  "CREDENTIAL_MIXED",
+  "CREDENTIAL_WRONG_FAMILY",
+  "OWNER_REQUIRED",
+  "ORIGIN_REJECTED",
+  "APPROVAL_REQUIRED",
+  "APPROVAL_REJECTED",
+  "APPROVAL_EXPIRED",
+  "APPROVAL_MISMATCH",
+  "SCOPE_REQUIRED",
+  "MODE_READ_ONLY",
+  "API_ACCESS_DISABLED",
+  "RESTAURANT_NOT_APPROVED",
+  "NOT_FOUND",
+  "VERSION_CONFLICT",
+  "IDEMPOTENCY_CONFLICT",
+  "INVALID_PRICE",
+  "UNCONFIRMED_DATA",
+  "REFERENCE_CONFLICT",
+  "MEDIA_INVALID",
+  "MEDIA_EXPIRED",
+  "QUOTA_EXCEEDED",
+  "RATE_LIMITED",
+  "PAIRING_PENDING",
+  "PAIRING_DENIED",
+  "PAIRING_EXPIRED",
+  "PAIRING_CONSUMED",
+  "OPERATION_TERMINAL",
+  "APPLY_WINDOW_EXPIRED",
+  "DEPENDENCY_FAILED",
+  "TEMPORARY_UNAVAILABLE",
+  "INTERNAL_ERROR"
+]);
+var elenaAgentErrorSchema = z.strictObject({
+  version: elenaAgentVersionSchema,
+  error: z.strictObject({
+    code: elenaAgentErrorCodeSchema,
+    message: z.string().max(500),
+    retryable: z.boolean(),
+    requestId: elenaAgentRefSchema,
+    retryAfterSeconds: z.number().int().min(1).max(3600).optional(),
+    issues: z.array(
+      z.strictObject({
+        path: z.string().max(200),
+        code: elenaAgentErrorCodeSchema,
+        message: z.string().max(200)
+      })
+    ).max(250).optional()
+  })
+});
+var elenaAgentPageQuerySchema = z.strictObject({
+  version: elenaAgentVersionSchema,
+  cursor: z.string().regex(/^[a-zA-Z0-9_-]{1,512}$/).optional(),
+  limit: z.number().int().min(1).max(ELENA_AGENT_LIMITS.pageSize).default(50)
+});
+var elenaAgentEmptyRequestSchema = z.strictObject({ version: elenaAgentVersionSchema });
+var elenaAgentAckSchema = z.strictObject({
+  version: elenaAgentVersionSchema,
+  ok: z.literal(true)
+});
+
+// ../shared/src/agent-contracts/access.ts
+var ELENA_AGENT_TRANSPORT = Object.freeze({
+  agentPrefix: "elena_sk_",
+  agentHeader: "x-elena-agent-key",
+  agentPath: "/api/v1/agent",
+  clientPrefix: "elena_pk_",
+  clientHeader: "x-elena-client-key",
+  clientPath: "/api/v1/public/sdk",
+  ownerPath: "/api/v1/agent-access"
+});
+var elenaAgentSecretSchema = z2.string().regex(/^elena_sk_[A-Za-z0-9_-]{43}$/);
+var elenaManualClientKeySchema = z2.string().regex(/^elena_pk_[A-Za-z0-9_-]{43}$/);
+var elenaManagedClientKeySchema = z2.string().max(160).regex(
+  /^elena_pk_m_[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.[1-9]\d{0,15}\.[A-Za-z0-9_-]{43}$/
+);
+var elenaClientKeySchema = z2.union([
+  elenaManualClientKeySchema,
+  elenaManagedClientKeySchema
+]);
+var elenaAgentDeviceCodeSchema = z2.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var elenaAgentUserCodeSchema = z2.string().regex(/^[A-HJ-NP-Z2-9]{4}-[A-HJ-NP-Z2-9]{4}$/);
+var elenaAgentModeSchema = z2.enum(["read", "mutate"]);
+var elenaAgentScopeSchema = z2.enum([
+  "catalog:read",
+  "catalog:write",
+  "catalog:publish",
+  "assets:read",
+  "assets:write"
+]);
+var elenaAgentScopesSchema = z2.array(elenaAgentScopeSchema).min(1).max(5).refine((scopes) => new Set(scopes).size === scopes.length, "Duplicate scope").refine((scopes) => scopes.includes("catalog:read"), "catalog:read is mandatory");
+var elenaAgentActionSchema = z2.enum([
+  "context.read",
+  "catalog.read",
+  "assets.read",
+  "assets.stage",
+  "operations.read",
+  "operations.propose",
+  "operations.apply",
+  "catalog.publish"
+]);
+var elenaAgentRestaurantSchema = z2.strictObject({
+  id: elenaAgentIdSchema,
+  name: elenaAgentNameSchema,
+  slug: z2.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).max(100),
+  currency: elenaAgentCurrencySchema
+});
+var keyTtl = z2.number().int().min(3600).max(ELENA_AGENT_LIMITS.keyMaxTtlSeconds).default(ELENA_AGENT_LIMITS.keyDefaultTtlSeconds);
+var elenaAgentKeyCreateRequestSchema = z2.discriminatedUnion("kind", [
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    kind: z2.literal("agent"),
+    label: elenaAgentNameSchema,
+    mode: elenaAgentModeSchema.default("read"),
+    scopes: elenaAgentScopesSchema.default(["catalog:read", "assets:read"]),
+    ttlSeconds: keyTtl
+  }),
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    kind: z2.literal("client"),
+    label: elenaAgentNameSchema,
+    ttlSeconds: keyTtl
+  })
+]);
+var elenaAgentKeyPolicyRequestSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  expectedRevision: elenaAgentRevisionSchema,
+  mode: elenaAgentModeSchema,
+  scopes: elenaAgentScopesSchema
+});
+var elenaAgentKeyRevokeRequestSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  expectedRevision: elenaAgentRevisionSchema
+});
+var elenaAgentKeyReplaceRequestSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  expectedRevision: elenaAgentRevisionSchema,
+  ttlSeconds: keyTtl
+});
+var keyMetadata = {
+  id: elenaAgentIdSchema,
+  label: elenaAgentNameSchema,
+  displaySuffix: z2.string().regex(/^[A-Za-z0-9_-]{6}$/),
+  revision: elenaAgentRevisionSchema,
+  status: z2.enum(["active", "revoked", "expired"]),
+  createdAt: elenaAgentTimestampSchema,
+  expiresAt: elenaAgentTimestampSchema,
+  revokedAt: elenaAgentTimestampSchema.nullable(),
+  lastUsedAt: elenaAgentTimestampSchema.nullable()
+};
+var elenaAgentKeyMetadataSchema = z2.discriminatedUnion("kind", [
+  z2.strictObject({
+    ...keyMetadata,
+    kind: z2.literal("agent"),
+    mode: elenaAgentModeSchema,
+    scopes: elenaAgentScopesSchema
+  }),
+  z2.strictObject({ ...keyMetadata, kind: z2.literal("client") })
+]);
+var elenaAgentKeyListSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  keys: z2.array(elenaAgentKeyMetadataSchema).max(20)
+});
+var elenaAgentKeyReceiptSchema = z2.discriminatedUnion("kind", [
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    kind: z2.literal("agent"),
+    key: elenaAgentKeyMetadataSchema.options[0],
+    secret: elenaAgentSecretSchema
+  }),
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    kind: z2.literal("client"),
+    key: elenaAgentKeyMetadataSchema.options[1],
+    clientKey: elenaManualClientKeySchema
+  })
+]);
+var elenaAgentKeyResponseSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  key: elenaAgentKeyMetadataSchema
+});
+var elenaAgentHttpsUrlSchema = z2.url({ protocol: /^https$/ }).max(2048).refine(
+  (value) => /^https:\/\/[^/?#@\\\s]+(?:[/?#]|$)/.test(value),
+  "URL must not contain userinfo"
+);
+var elenaAgentConnectionUrlSchema = z2.url({ protocol: /^https?$/ }).max(2048).refine(
+  (value) => /^https?:\/\/[^/?#@\\\s]+(?:[/?#]|$)/.test(value),
+  "URL must not contain userinfo"
+);
+var elenaAgentBaseUrlSchema = elenaAgentHttpsUrlSchema.refine(
+  (value) => /^https:\/\/[^/?#@\\\s]+\/?$/.test(value),
+  "Base URL must be an explicit origin"
+);
+var elenaAgentConnectionOriginSchema = elenaAgentConnectionUrlSchema.refine(
+  (value) => /^https?:\/\/[^/?#@\\\s]+\/?$/.test(value),
+  "Base URL must be an explicit origin"
+);
+var elenaAgentPairingStartRequestSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  label: elenaAgentNameSchema
+});
+var elenaAgentPairingStartResponseSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  pairingId: elenaAgentIdSchema,
+  deviceCode: elenaAgentDeviceCodeSchema,
+  userCode: elenaAgentUserCodeSchema,
+  verificationUrl: elenaAgentConnectionUrlSchema,
+  expiresAt: elenaAgentTimestampSchema,
+  intervalSeconds: z2.literal(ELENA_AGENT_LIMITS.pairingPollSeconds)
+});
+var elenaAgentPairingPollRequestSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  deviceCode: elenaAgentDeviceCodeSchema
+});
+var elenaAgentPairingReviewSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  label: elenaAgentNameSchema,
+  userCode: elenaAgentUserCodeSchema,
+  state: z2.enum(["pending", "approved", "rejected", "expired", "consumed"]),
+  expiresAt: elenaAgentTimestampSchema
+});
+var elenaAgentPairingDecisionRequestSchema = z2.discriminatedUnion("decision", [
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    userCode: elenaAgentUserCodeSchema,
+    decision: z2.literal("approve"),
+    mode: elenaAgentModeSchema.default("read"),
+    scopes: elenaAgentScopesSchema.default(["catalog:read", "assets:read"]),
+    ttlSeconds: keyTtl
+  }),
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    userCode: elenaAgentUserCodeSchema,
+    decision: z2.literal("reject")
+  })
+]);
+var elenaAgentPairingPollResponseSchema = z2.discriminatedUnion("status", [
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    status: z2.literal("pending"),
+    expiresAt: elenaAgentTimestampSchema,
+    intervalSeconds: z2.literal(ELENA_AGENT_LIMITS.pairingPollSeconds)
+  }),
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    status: z2.literal("delivered"),
+    restaurant: elenaAgentRestaurantSchema,
+    credential: elenaAgentKeyReceiptSchema.options[0]
+  })
+]);
+var elenaAgentContextSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  restaurant: elenaAgentRestaurantSchema,
+  principal: z2.strictObject({
+    kind: z2.literal("agent"),
+    credentialId: elenaAgentIdSchema,
+    credentialRevision: elenaAgentRevisionSchema,
+    mode: elenaAgentModeSchema,
+    scopes: elenaAgentScopesSchema,
+    expiresAt: elenaAgentTimestampSchema
+  }),
+  capabilities: z2.strictObject({
+    apiAccess: z2.literal(true),
+    menu: z2.literal(true),
+    imports: z2.boolean(),
+    media: z2.boolean(),
+    publication: z2.boolean()
+  }),
+  actions: z2.array(elenaAgentActionSchema).min(1).max(8).refine((actions) => new Set(actions).size === actions.length, "Duplicate action")
+}).superRefine((value, ctx) => {
+  const requiredScopes = {
+    "catalog.read": "catalog:read",
+    "assets.read": "assets:read",
+    "assets.stage": "assets:write",
+    "operations.propose": "catalog:write",
+    "operations.apply": "catalog:write",
+    "catalog.publish": "catalog:publish"
+  };
+  const writes = {
+    "assets.stage": true,
+    "operations.propose": true,
+    "operations.apply": true,
+    "catalog.publish": true
+  };
+  for (const action of value.actions) {
+    if (value.principal.mode === "read" && writes[action]) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["actions"],
+        message: "Read mode cannot expose mutation actions"
+      });
+    }
+    const scope = requiredScopes[action];
+    if (scope && !value.principal.scopes.includes(scope)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["actions"],
+        message: "Action exceeds granted scopes"
+      });
+    }
+  }
+  if (value.actions.includes("catalog.publish") && !value.principal.scopes.includes("catalog:write")) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["actions"],
+      message: "Publication also requires catalog:write"
+    });
+  }
+  const expectedCapabilities = {
+    imports: value.actions.includes("operations.propose") && value.actions.includes("operations.apply"),
+    media: value.actions.includes("assets.stage"),
+    publication: value.actions.includes("catalog.publish")
+  };
+  for (const capability of ["imports", "media", "publication"]) {
+    if (value.capabilities[capability] !== expectedCapabilities[capability]) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["capabilities", capability],
+        message: "Capability must match effective actions"
+      });
+    }
+  }
+});
+var elenaClientContextSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  restaurant: elenaAgentRestaurantSchema,
+  capabilities: z2.strictObject({ menu: z2.literal(true), assets: z2.literal(true) })
+});
+var elenaAgentCliAuthStatusSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  authenticated: z2.boolean(),
+  source: z2.enum(["store", "environment", "none"]),
+  baseUrl: elenaAgentBaseUrlSchema.nullable(),
+  credentialId: elenaAgentIdSchema.nullable(),
+  restaurantId: elenaAgentIdSchema.nullable(),
+  expiresAt: elenaAgentTimestampSchema.nullable()
+});
+var elenaAgentCliLogoutSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  loggedOut: z2.literal(true),
+  remoteRevoked: z2.literal(false),
+  environmentCredentialPresent: z2.boolean()
+});
+
+// ../shared/src/agent-contracts/catalog.ts
+import { z as z3 } from "zod";
+var elenaAgentExistingTargetSchema = z3.strictObject({
+  kind: z3.literal("id"),
+  id: elenaAgentIdSchema,
+  expectedVersion: elenaAgentRevisionSchema
+});
+var elenaAgentExternalTargetSchema = z3.strictObject({
+  kind: z3.literal("external"),
+  namespace: elenaAgentRefSchema,
+  key: elenaAgentRefSchema,
+  expectedVersion: elenaAgentRevisionSchema.nullable()
+});
+var elenaAgentTargetSchema = z3.discriminatedUnion("kind", [
+  elenaAgentExistingTargetSchema,
+  elenaAgentExternalTargetSchema
+]);
+var elenaAgentCategoryReferenceSchema = z3.discriminatedUnion("kind", [
+  elenaAgentExistingTargetSchema,
+  z3.strictObject({ kind: z3.literal("ref"), ref: elenaAgentRefSchema })
+]);
+var elenaAgentDescriptionSchema = z3.discriminatedUnion("status", [
+  z3.strictObject({ status: z3.literal("transcribed"), text: elenaAgentTextSchema }),
+  z3.strictObject({ status: z3.literal("proposed"), text: elenaAgentTextSchema })
+]);
+var elenaAgentConfirmedPriceSchema = z3.strictObject({
+  status: z3.literal("confirmed"),
+  amount: elenaAgentMoneySchema,
+  basis: z3.literal("operator")
+});
+var elenaAgentDraftPriceSchema = z3.discriminatedUnion("status", [
+  elenaAgentConfirmedPriceSchema,
+  z3.strictObject({
+    status: z3.literal("unconfirmed"),
+    reason: z3.enum(["missing", "illegible"]),
+    rawText: z3.string().max(100).nullable()
+  })
+]);
+var elenaAgentMediaReferenceSchema = z3.discriminatedUnion("kind", [
+  z3.strictObject({
+    kind: z3.literal("existing"),
+    assetId: elenaAgentIdSchema,
+    sha256: elenaAgentHashSchema
+  }),
+  z3.strictObject({
+    kind: z3.literal("staged"),
+    stagingId: elenaAgentIdSchema,
+    sha256: elenaAgentHashSchema
+  })
+]);
+var elenaAgentGallerySchema = z3.array(elenaAgentMediaReferenceSchema).max(ELENA_AGENT_LIMITS.galleryImages).refine(
+  (images) => new Set(images.map((image) => image.kind === "existing" ? image.assetId : image.stagingId)).size === images.length,
+  "Duplicate media reference"
+);
+var elenaAgentExtraOptionSchema = z3.strictObject({
+  name: elenaAgentNameSchema,
+  additionalPrice: elenaAgentNonnegativeMoneySchema,
+  order: z3.number().int().min(0).max(1e3)
+});
+var elenaAgentExtraGroupSchema = z3.strictObject({
+  name: elenaAgentNameSchema,
+  required: z3.boolean(),
+  minSelections: z3.number().int().min(0).max(ELENA_AGENT_LIMITS.optionsPerGroup),
+  maxSelections: z3.number().int().min(1).max(ELENA_AGENT_LIMITS.optionsPerGroup),
+  order: z3.number().int().min(0).max(1e3),
+  options: z3.array(elenaAgentExtraOptionSchema).min(1).max(ELENA_AGENT_LIMITS.optionsPerGroup)
+}).superRefine((group, ctx) => {
+  if (group.minSelections > group.maxSelections || group.maxSelections > group.options.length) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["maxSelections"],
+      message: "Invalid selection bounds"
+    });
+  }
+  if (group.required && group.minSelections < 1 || !group.required && group.minSelections !== 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["minSelections"],
+      message: "Required must match minimum selection count"
+    });
+  }
+  if (new Set(
+    group.options.map((option) => option.name.normalize("NFKC").trim().toLocaleLowerCase("es"))
+  ).size !== group.options.length) {
+    ctx.addIssue({ code: "custom", path: ["options"], message: "Duplicate option name" });
+  }
+});
+var elenaAgentExtrasSchema = z3.strictObject({
+  confirmed: z3.literal(true),
+  groups: z3.array(elenaAgentExtraGroupSchema).max(ELENA_AGENT_LIMITS.extraGroups)
+}).refine(
+  (extras) => new Set(
+    extras.groups.map((group) => group.name.normalize("NFKC").trim().toLocaleLowerCase("es"))
+  ).size === extras.groups.length,
+  "Duplicate group name"
+);
+var elenaAgentCategoryDataSchema = z3.strictObject({
+  name: elenaAgentNameSchema,
+  description: elenaAgentDescriptionSchema.nullable(),
+  order: z3.number().int().min(0).max(1e4)
+});
+var productFields = {
+  type: z3.literal("menu"),
+  name: elenaAgentNameSchema,
+  description: elenaAgentDescriptionSchema.nullable(),
+  category: elenaAgentCategoryReferenceSchema,
+  available: z3.boolean(),
+  images: elenaAgentGallerySchema,
+  extras: elenaAgentExtrasSchema
+};
+var elenaAgentProductDataSchema = z3.strictObject({
+  ...productFields,
+  price: elenaAgentConfirmedPriceSchema
+});
+var elenaAgentDraftProductDataSchema = z3.strictObject({
+  ...productFields,
+  price: elenaAgentDraftPriceSchema
+});
+var elenaAgentCategoryChangeSchema = z3.strictObject({
+  kind: z3.literal("category.upsert"),
+  ref: elenaAgentRefSchema,
+  target: elenaAgentTargetSchema,
+  data: elenaAgentCategoryDataSchema
+});
+var elenaAgentProductChangeSchema = z3.strictObject({
+  kind: z3.literal("product.upsert"),
+  ref: elenaAgentRefSchema,
+  target: elenaAgentTargetSchema,
+  data: elenaAgentProductDataSchema
+});
+var elenaAgentChangeSchema = z3.discriminatedUnion("kind", [
+  elenaAgentCategoryChangeSchema,
+  elenaAgentProductChangeSchema
+]);
+var elenaAgentCategorySchema = z3.strictObject({
+  id: elenaAgentIdSchema,
+  revision: elenaAgentRevisionSchema,
+  name: elenaAgentNameSchema,
+  description: elenaAgentTextSchema.nullable(),
+  order: z3.number().int().min(0).max(1e4)
+});
+var elenaAgentProductSchema = z3.strictObject({
+  id: elenaAgentIdSchema,
+  revision: elenaAgentRevisionSchema,
+  type: z3.literal("menu"),
+  name: elenaAgentNameSchema,
+  basePrice: elenaAgentMoneySchema,
+  description: elenaAgentTextSchema.nullable(),
+  categoryId: elenaAgentIdSchema,
+  available: z3.boolean(),
+  publishedToMenu: z3.boolean(),
+  isDraft: z3.boolean(),
+  images: z3.array(z3.strictObject({ assetId: elenaAgentIdSchema, sha256: elenaAgentHashSchema })).max(ELENA_AGENT_LIMITS.galleryImages),
+  /** Present on current native reads; optional only for retained v1 snapshots. */
+  primaryImageId: elenaAgentIdSchema.nullable().optional(),
+  extraGroups: z3.array(elenaAgentExtraGroupSchema).max(ELENA_AGENT_LIMITS.extraGroups)
+});
+var elenaAgentCategoryListSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  categories: z3.array(elenaAgentCategorySchema).max(ELENA_AGENT_LIMITS.pageSize),
+  nextCursor: z3.string().regex(/^[a-zA-Z0-9_-]{1,512}$/).nullable()
+});
+var elenaAgentProductListSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  products: z3.array(elenaAgentProductSchema).max(ELENA_AGENT_LIMITS.pageSize),
+  nextCursor: z3.string().regex(/^[a-zA-Z0-9_-]{1,512}$/).nullable()
+});
+var elenaAgentProductResponseSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  product: elenaAgentProductSchema,
+  /** Authoritative editing metadata; never infer primary image from gallery order. */
+  editable: z3.strictObject({
+    restaurantId: elenaAgentIdSchema,
+    productId: elenaAgentIdSchema,
+    imageId: elenaAgentIdSchema.nullable(),
+    categoryRevision: elenaAgentRevisionSchema,
+    primaryImage: z3.strictObject({ assetId: elenaAgentIdSchema, sha256: elenaAgentHashSchema }).nullable().optional(),
+    imageEditorUrl: elenaAgentHttpsUrlSchema.optional()
+  }).optional()
+});
+var elenaAgentCategoryResponseSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  category: elenaAgentCategorySchema
+});
+var elenaAgentMediaStageRequestSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  idempotencyKey: elenaAgentRefSchema,
+  fileName: z3.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,119}\.(?:jpg|jpeg|png|webp)$/),
+  mimeType: z3.enum(["image/jpeg", "image/png", "image/webp"]),
+  bytes: z3.number().int().min(1).max(ELENA_AGENT_LIMITS.mediaBytes),
+  sha256: elenaAgentHashSchema
+});
+var elenaAgentMediaStagedSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  stagingId: elenaAgentIdSchema,
+  sha256: elenaAgentHashSchema,
+  mimeType: z3.enum(["image/jpeg", "image/png", "image/webp"]),
+  bytes: z3.number().int().min(1).max(ELENA_AGENT_LIMITS.mediaBytes),
+  expiresAt: elenaAgentTimestampSchema
+});
+var elenaAgentAssetSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  assetId: elenaAgentIdSchema,
+  sha256: elenaAgentHashSchema,
+  mimeType: z3.enum(["image/jpeg", "image/png", "image/webp"]),
+  bytes: z3.number().int().min(1).max(ELENA_AGENT_LIMITS.mediaBytes)
+});
+var elenaClientAssetSchema = z3.strictObject({
+  assetId: elenaAgentIdSchema,
+  url: elenaAgentHttpsUrlSchema
+});
+var elenaClientCategorySchema = z3.strictObject({
+  id: elenaAgentIdSchema,
+  name: elenaAgentNameSchema,
+  description: elenaAgentTextSchema.nullable(),
+  order: z3.number().int().min(0).max(1e4)
+});
+var elenaClientProductSchema = z3.strictObject({
+  id: elenaAgentIdSchema,
+  type: z3.literal("menu"),
+  name: elenaAgentNameSchema,
+  basePrice: elenaAgentMoneySchema,
+  description: elenaAgentTextSchema.nullable(),
+  categoryId: elenaAgentIdSchema,
+  available: z3.boolean(),
+  images: z3.array(elenaClientAssetSchema).max(ELENA_AGENT_LIMITS.galleryImages),
+  extraGroups: z3.array(elenaAgentExtraGroupSchema).max(ELENA_AGENT_LIMITS.extraGroups)
+});
+var elenaClientCatalogSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  categories: z3.array(elenaClientCategorySchema).max(ELENA_AGENT_LIMITS.pageSize),
+  products: z3.array(elenaClientProductSchema).max(ELENA_AGENT_LIMITS.pageSize),
+  nextCursor: z3.string().regex(/^[a-zA-Z0-9_-]{1,512}$/).nullable()
+});
+var elenaClientProductResponseSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  product: elenaClientProductSchema
+});
+var elenaClientAssetResponseSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  asset: elenaClientAssetSchema
+});
+
+// src/key-transport.ts
+var ElenaAgentTransportError = class extends Error {
+  constructor(code, status = 0, retryable = false, requestId = null, retryAfterSeconds) {
+    super(`Elena request failed (${code}).`);
+    this.code = code;
+    this.status = status;
+    this.retryable = retryable;
+    this.requestId = requestId;
+    this.retryAfterSeconds = retryAfterSeconds;
+  }
+  code;
+  status;
+  retryable;
+  requestId;
+  retryAfterSeconds;
+  name = "ElenaAgentTransportError";
+};
+function parseWire(schema, value, response = false) {
+  let unsupportedVersion = false;
+  try {
+    if (value !== null && typeof value === "object" && "version" in value) {
+      unsupportedVersion = value.version !== void 0 && value.version !== "1";
+    }
+    const parsed = schema.safeParse(value);
+    if (parsed.success) return parsed.data;
+  } catch {
+  }
+  throw new ElenaAgentTransportError(
+    unsupportedVersion ? "UNSUPPORTED_VERSION" : response ? "INVALID_RESPONSE" : "INVALID_REQUEST"
+  );
+}
+function assertOptionKeys(value, keys) {
+  if (!value || typeof value !== "object" || Object.keys(value).some((key) => !keys.includes(key))) {
+    throw new ElenaAgentTransportError("INVALID_REQUEST");
+  }
+}
+function explicitOrigin(value, allowTestHttp = false) {
+  try {
+    if (typeof value !== "string" || !/^https?:\/\/[^/?#@\\\s]+\/?$/.test(value)) throw 0;
+    if (/elena_(?:sk|pk)_/i.test(value)) throw 0;
+    const url = new URL(value);
+    const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && (typeof process !== "undefined" && process.env.NODE_ENV === "development" || allowTestHttp && loopback)))
+      throw 0;
+    if (url.username || url.password || url.search || url.hash || url.pathname !== "/") throw 0;
+    return url.origin;
+  } catch {
+    throw new ElenaAgentTransportError("ORIGIN_REJECTED");
+  }
+}
+function resourceId(value) {
+  return parseWire(elenaAgentIdSchema, value);
+}
+function pageQuery(value = { version: "1" }) {
+  const query = parseWire(elenaAgentPageQuerySchema, value);
+  const params = new URLSearchParams({ version: query.version, limit: String(query.limit) });
+  if (query.cursor !== void 0) params.set("cursor", query.cursor);
+  return `?${params}`;
+}
+function timeoutValue(value) {
+  if (!Number.isInteger(value) || value < 1 || value > 3e5) {
+    throw new ElenaAgentTransportError("INVALID_REQUEST");
+  }
+  return value;
+}
+var privateCredential = /elena_sk_[A-Za-z0-9_-]{43}/;
+var retryCodes = {
+  RATE_LIMITED: true,
+  TEMPORARY_UNAVAILABLE: true
+};
+function createKeyTransport(options, header, credential) {
+  if (options.testing !== void 0) {
+    assertOptionKeys(options.testing, ["allowHttp"]);
+    if (options.testing.allowHttp !== true || !options.fetch) {
+      throw new ElenaAgentTransportError("INVALID_REQUEST");
+    }
+  }
+  const baseUrl = explicitOrigin(options.baseUrl, options.testing?.allowHttp === true);
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") throw new ElenaAgentTransportError("INVALID_REQUEST");
+  const defaultTimeout = timeoutValue(options.timeoutMs ?? 3e4);
+  const retries = options.maxRetries ?? 2;
+  if (!Number.isInteger(retries) || retries < 0 || retries > 2) {
+    throw new ElenaAgentTransportError("INVALID_REQUEST");
+  }
+  async function request(path, schema, requestOptions = {}, body, stage = false, retryAmbiguous = true) {
+    assertOptionKeys(requestOptions, ["signal", "timeoutMs"]);
+    if (privateCredential.test(path) || credential && path.includes(credential) || typeof body === "string" && (privateCredential.test(body) || credential && body.includes(credential))) {
+      throw new ElenaAgentTransportError("INVALID_REQUEST");
+    }
+    if (requestOptions.signal !== void 0 && !(requestOptions.signal instanceof AbortSignal)) {
+      throw new ElenaAgentTransportError("INVALID_REQUEST");
+    }
+    const timeoutMs = timeoutValue(requestOptions.timeoutMs ?? (stage ? 12e4 : defaultTimeout));
+    if (requestOptions.signal?.aborted) throw new ElenaAgentTransportError("ABORTED");
+    const controller = new AbortController();
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    const onAbort = () => controller.abort();
+    requestOptions.signal?.addEventListener("abort", onAbort, { once: true });
+    const abortError = () => new ElenaAgentTransportError(timedOut ? "TIMEOUT" : "ABORTED");
+    const deadline = Date.now() + timeoutMs;
+    const bounded = (promise) => new Promise((resolve, reject) => {
+      const abort = () => {
+        cleanup();
+        reject(abortError());
+      };
+      const cleanup = () => controller.signal.removeEventListener("abort", abort);
+      if (controller.signal.aborted) {
+        reject(abortError());
+        return;
+      }
+      controller.signal.addEventListener("abort", abort, { once: true });
+      promise.then(
+        (value) => {
+          cleanup();
+          resolve(value);
+        },
+        (error) => {
+          cleanup();
+          reject(error);
+        }
+      );
+    });
+    const delay = (ms) => new Promise((resolve, reject) => {
+      const abort = () => {
+        clearTimeout(wait);
+        controller.signal.removeEventListener("abort", abort);
+        reject(abortError());
+      };
+      const wait = setTimeout(() => {
+        controller.signal.removeEventListener("abort", abort);
+        resolve();
+      }, ms);
+      controller.signal.addEventListener("abort", abort, { once: true });
+      if (controller.signal.aborted) abort();
+    });
+    try {
+      for (let attempt = 0; ; attempt++) {
+        let failure;
+        let retryDelay = 100 * 2 ** attempt;
+        try {
+          const headers = new Headers({ Accept: "application/json" });
+          if (header) headers.set(header, credential);
+          if (typeof body === "string") headers.set("Content-Type", "application/json");
+          const response = await bounded(
+            Promise.resolve().then(() => {
+              if (controller.signal.aborted) throw abortError();
+              return fetchImpl(`${baseUrl}${path}`, {
+                method: body === void 0 ? "GET" : "POST",
+                headers,
+                body: typeof body === "function" ? body() : body,
+                credentials: "omit",
+                redirect: "error",
+                referrerPolicy: "no-referrer",
+                cache: "no-store",
+                signal: controller.signal
+              });
+            }).catch(() => {
+              throw new ElenaAgentTransportError("NETWORK_ERROR", 0, retryAmbiguous);
+            })
+          );
+          if (response.redirected || response.status >= 300 && response.status < 400) {
+            throw new ElenaAgentTransportError("REDIRECT_REJECTED", response.status);
+          }
+          if (response.url && new URL(response.url).origin !== baseUrl) {
+            throw new ElenaAgentTransportError("ORIGIN_REJECTED");
+          }
+          const text = await bounded(
+            Promise.resolve().then(() => response.text()).catch(() => {
+              throw new ElenaAgentTransportError("NETWORK_ERROR", 0, retryAmbiguous);
+            })
+          );
+          if (privateCredential.test(text) || credential && text.includes(credential)) {
+            throw new ElenaAgentTransportError("INVALID_RESPONSE", response.status);
+          }
+          let payload;
+          try {
+            payload = JSON.parse(text);
+          } catch {
+            throw new ElenaAgentTransportError("INVALID_RESPONSE", response.status);
+          }
+          const decodedText = JSON.stringify(payload);
+          if (privateCredential.test(decodedText) || credential && decodedText.includes(credential)) {
+            throw new ElenaAgentTransportError("INVALID_RESPONSE", response.status);
+          }
+          if (response.ok) return parseWire(schema, payload, true);
+          const wire = parseWire(elenaAgentErrorSchema, payload, true).error;
+          const retryable = retryCodes[wire.code] === true && wire.retryable && (wire.code === "RATE_LIMITED" && response.status === 429 || wire.code === "TEMPORARY_UNAVAILABLE" && response.status === 503);
+          failure = new ElenaAgentTransportError(
+            wire.code,
+            response.status,
+            retryable,
+            wire.requestId,
+            wire.retryAfterSeconds
+          );
+          const retryAfter = response.headers.get("retry-after");
+          let headerDelay = 0;
+          if (retryAfter !== null) {
+            const seconds = /^\d+$/.test(retryAfter) ? Number(retryAfter) : (Date.parse(retryAfter) - Date.now()) / 1e3;
+            if (!Number.isFinite(seconds) || seconds < 0 || seconds > 3600) {
+              throw new ElenaAgentTransportError(
+                wire.code,
+                response.status,
+                false,
+                wire.requestId,
+                wire.retryAfterSeconds
+              );
+            }
+            headerDelay = Math.ceil(seconds * 1e3);
+          }
+          retryDelay = Math.max(retryDelay, headerDelay, (wire.retryAfterSeconds ?? 0) * 1e3);
+        } catch (error) {
+          if (controller.signal.aborted) throw abortError();
+          failure = error instanceof ElenaAgentTransportError ? error : new ElenaAgentTransportError("NETWORK_ERROR", 0, retryAmbiguous);
+        }
+        if (!failure.retryable || attempt >= retries || Date.now() + retryDelay >= deadline)
+          throw failure;
+        await delay(retryDelay);
+      }
+    } finally {
+      clearTimeout(timer);
+      requestOptions.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  return { request };
+}
+
+// src/client-key.ts
+function createElenaClientKeyClient(options) {
+  assertOptionKeys(options, [
+    "baseUrl",
+    "clientKey",
+    "fetch",
+    "timeoutMs",
+    "maxRetries",
+    "testing"
+  ]);
+  if (!elenaClientKeySchema.safeParse(options.clientKey).success) {
+    throw new ElenaAgentTransportError("CREDENTIAL_WRONG_FAMILY");
+  }
+  const { request } = createKeyTransport(options, "x-elena-client-key", options.clientKey);
+  const root = "/api/v1/public/sdk";
+  return Object.freeze({
+    context: Object.freeze({
+      get: (options2) => request(`${root}/context`, elenaClientContextSchema, options2)
+    }),
+    catalog: Object.freeze({
+      list: (query, options2) => request(`${root}/catalog${pageQuery(query)}`, elenaClientCatalogSchema, options2),
+      getProduct: async (id, options2) => {
+        const expectedId = resourceId(id);
+        const result = await request(
+          `${root}/catalog/products/${expectedId}`,
+          elenaClientProductResponseSchema,
+          options2
+        );
+        if (result.product.id !== expectedId)
+          throw new ElenaAgentTransportError("INVALID_RESPONSE");
+        return result;
+      }
+    }),
+    assets: Object.freeze({
+      get: async (id, options2) => {
+        const expectedId = resourceId(id);
+        const result = await request(
+          `${root}/assets/${expectedId}`,
+          elenaClientAssetResponseSchema,
+          options2
+        );
+        if (result.asset.assetId !== expectedId)
+          throw new ElenaAgentTransportError("INVALID_RESPONSE");
+        return result;
+      }
+    })
+  });
+}
+
+// ../shared/src/agent-contracts/public-connection.ts
+import { z as z4 } from "zod";
+var ELENA_PUBLIC_CONNECTION_DISCOVERY_ROOT = "/api/v1/public/catalog-connections";
+var elenaPublicConnectionSlugSchema = z4.string().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+var ttl = z4.number().int().min(3600).max(ELENA_AGENT_LIMITS.keyMaxTtlSeconds).default(ELENA_AGENT_LIMITS.keyDefaultTtlSeconds);
+var mutation = {
+  version: elenaAgentVersionSchema,
+  // Zero asserts that no connection has ever been created for this restaurant.
+  expectedRevision: z4.number().int().min(0).max(Number.MAX_SAFE_INTEGER - 1)
+};
+var elenaPublicConnectionMutationSchema = z4.discriminatedUnion("action", [
+  z4.strictObject({ ...mutation, action: z4.literal("enable"), ttlSeconds: ttl }),
+  z4.strictObject({ ...mutation, action: z4.literal("renew"), ttlSeconds: ttl }),
+  z4.strictObject({ ...mutation, action: z4.literal("disable") }),
+  z4.strictObject({ ...mutation, action: z4.literal("revoke") })
+]);
+var elenaPublicConnectionMetadataSchema = z4.strictObject({
+  revision: elenaAgentRevisionSchema,
+  status: z4.enum(["published", "disabled", "revoked"]),
+  expiresAt: elenaAgentTimestampSchema
+});
+var elenaPublicConnectionManagementSchema = z4.strictObject({
+  version: elenaAgentVersionSchema,
+  publication: elenaPublicConnectionMetadataSchema.nullable()
+});
+var elenaPublicConnectionSchema = z4.strictObject({
+  version: elenaAgentVersionSchema,
+  apiOrigin: elenaAgentBaseUrlSchema,
+  clientKey: elenaManagedClientKeySchema,
+  publication: z4.strictObject({
+    revision: elenaAgentRevisionSchema,
+    expiresAt: elenaAgentTimestampSchema
+  }),
+  context: elenaClientContextSchema
+});
+
+// src/public-connection.ts
+async function discoverElenaPublicConnection(options, slug, requestOptions) {
+  assertOptionKeys(options, ["baseUrl", "fetch", "timeoutMs", "maxRetries", "testing"]);
+  const identifier = parseWire(elenaPublicConnectionSlugSchema, slug);
+  const result = await createKeyTransport(options, null, "").request(
+    `${ELENA_PUBLIC_CONNECTION_DISCOVERY_ROOT}/${identifier}`,
+    elenaPublicConnectionSchema,
+    requestOptions
+  );
+  if (explicitOrigin(result.apiOrigin) !== explicitOrigin(options.baseUrl, options.testing?.allowHttp) || result.context.restaurant.slug !== identifier)
+    throw new ElenaAgentTransportError("ORIGIN_REJECTED");
+  return result;
+}
+export {
+  AccessResource,
+  AssetsResource,
+  BusinessScope,
+  CatalogResource,
+  ChatResource,
+  ContinuationsResource,
+  ElenaAgentTransportError,
+  ElenaApiError,
+  ElenaCheckoutValidationError,
+  ElenaHttpClient,
+  ElenaNetworkError,
+  ElenaRequestAbortedError,
+  ElenaResponseError,
+  ElenaTimeoutError,
+  EventsResource,
+  JourneyConflictError,
+  JourneyResource,
+  OrdersResource,
+  PresenceResource,
+  RealtimeResource,
+  ReceiptsResource,
+  TablesResource,
+  TicketsResource,
+  buildOrderItems,
+  createElenaClientKeyClient,
+  createElenaJourneyClient,
+  createElenaPublicClient,
+  discoverElenaPublicConnection
+};
+//# sourceMappingURL=index.js.map