@zi2/relay-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,2537 @@
+// src/constants.ts
+var RELAY_MESSAGE_TYPES = {
+  AUTH: "auth",
+  SEND_SMS: "send_sms",
+  SMS_ACK: "sms_ack",
+  DELIVERY_RECEIPT: "delivery_receipt",
+  PONG: "pong",
+  STATUS: "status",
+  REKEY: "rekey",
+  REKEY_ACK: "rekey_ack"
+};
+var RELAY_STATUS = {
+  ACTIVE: "active",
+  INACTIVE: "inactive",
+  REVOKED: "revoked",
+  DEGRADED: "degraded"
+};
+var RELAY_MESSAGE_STATUS = {
+  PENDING: "pending",
+  SENT_TO_DEVICE: "sent_to_device",
+  DELIVERED: "delivered",
+  FAILED: "failed",
+  EXPIRED: "expired"
+};
+var RELAY_DELIVERY_STATUS = {
+  SENT: "sent",
+  DELIVERED: "delivered",
+  FAILED: "failed"
+};
+var RELAY_PAIRING_STATUS = {
+  PENDING: "pending",
+  COMPLETED: "completed",
+  EXPIRED: "expired"
+};
+var RELAY_LIMITS = {
+  AUTH_TIMEOUT_MS: 5e3,
+  HEARTBEAT_INTERVAL_MS: 3e4,
+  PAIRING_EXPIRY_MINUTES: 5,
+  MESSAGE_EXPIRY_HOURS: 24,
+  QUEUE_DRAIN_DELAY_MS: 3e3,
+  DEFAULT_SMS_TIMEOUT_MS: 3e4,
+  MAX_SMS_PER_MINUTE: 20,
+  MAX_SMS_PER_HOUR: 200,
+  MAX_SMS_PER_DAY: 1e3,
+  DEGRADED_THRESHOLD_MS: 5 * 60 * 1e3
+};
+var RELAY_PLATFORMS = {
+  ANDROID: "android",
+  IOS: "ios"
+};
+
+// src/core/queue-service.ts
+import { EventEmitter } from "events";
+
+// src/core/crypto/e2e.ts
+import crypto2 from "crypto";
+var E2E_HKDF_INFO = "zi2-relay-e2e-v1";
+function zeroBuffer(buf) {
+  buf.fill(0);
+}
+function generateX25519KeyPair() {
+  const { publicKey, privateKey } = crypto2.generateKeyPairSync("x25519");
+  return {
+    publicKey: publicKey.export({ type: "spki", format: "der" }).toString("hex"),
+    privateKey: privateKey.export({ type: "pkcs8", format: "der" }).toString("hex")
+  };
+}
+function deriveSharedKey(privateKeyHex, publicKeyHex) {
+  const privateKey = crypto2.createPrivateKey({
+    key: Buffer.from(privateKeyHex, "hex"),
+    format: "der",
+    type: "pkcs8"
+  });
+  const publicKey = crypto2.createPublicKey({
+    key: Buffer.from(publicKeyHex, "hex"),
+    format: "der",
+    type: "spki"
+  });
+  const sharedSecret = crypto2.diffieHellman({ privateKey, publicKey });
+  const derived = Buffer.from(
+    crypto2.hkdfSync("sha256", sharedSecret, Buffer.alloc(0), E2E_HKDF_INFO, 32)
+  );
+  zeroBuffer(sharedSecret);
+  return derived;
+}
+function encryptE2E(plaintext, sharedKey) {
+  const iv = crypto2.randomBytes(12);
+  const cipher = crypto2.createCipheriv("aes-256-gcm", sharedKey, iv);
+  const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  return `${iv.toString("hex")}:${authTag.toString("hex")}:${encrypted.toString("hex")}`;
+}
+function decryptE2E(ciphertext, sharedKey) {
+  const [ivHex, authTagHex, encryptedHex] = ciphertext.split(":");
+  if (!ivHex || !authTagHex || !encryptedHex) throw new Error("Invalid E2E ciphertext format");
+  const iv = Buffer.from(ivHex, "hex");
+  const authTag = Buffer.from(authTagHex, "hex");
+  const encrypted = Buffer.from(encryptedHex, "hex");
+  const decipher = crypto2.createDecipheriv("aes-256-gcm", sharedKey, iv);
+  decipher.setAuthTag(authTag);
+  return decipher.update(encrypted).toString("utf8") + decipher.final("utf8");
+}
+
+// src/core/connections.ts
+var relayConnections = /* @__PURE__ */ new Map();
+function getRelaySocket(relayId) {
+  return relayConnections.get(relayId);
+}
+function setRelaySocket(relayId, ws) {
+  relayConnections.set(relayId, ws);
+}
+function deleteRelaySocket(relayId) {
+  relayConnections.delete(relayId);
+}
+function isRelayOnline(relayId) {
+  const ws = relayConnections.get(relayId);
+  return !!ws && ws.readyState === 1;
+}
+
+// src/core/queue-service.ts
+function createQueueService(deps) {
+  const { db, encryption, logger, events, limits } = deps;
+  const ackEmitter = new EventEmitter();
+  ackEmitter.setMaxListeners(1e4);
+  async function enqueueAndWait(options) {
+    const { relayId, orgId, to, body, timeoutMs = limits.DEFAULT_SMS_TIMEOUT_MS } = options;
+    const relay = await db.findRelay(relayId, orgId);
+    if (!relay || relay.status !== RELAY_STATUS.ACTIVE && relay.status !== RELAY_STATUS.DEGRADED) {
+      throw new Error("Relay not found or inactive");
+    }
+    let sharedKeyHex;
+    try {
+      sharedKeyHex = encryption.decrypt(relay.sharedKeyEncrypted);
+    } catch (err) {
+      throw new Error(`Failed to decrypt relay shared key: ${err}`);
+    }
+    const sharedKey = Buffer.from(sharedKeyHex, "hex");
+    const payload = JSON.stringify({ to, body });
+    const encryptedPayload = encryptE2E(payload, sharedKey);
+    const message = await db.createMessage({
+      relayId,
+      organizationId: orgId,
+      encryptedPayload,
+      expiresAt: new Date(Date.now() + limits.MESSAGE_EXPIRY_HOURS * 60 * 60 * 1e3)
+    });
+    if (!isRelayOnline(relayId)) {
+      return { messageId: message.id, status: "queued" };
+    }
+    const ws = getRelaySocket(relayId);
+    if (!ws || ws.readyState !== 1) {
+      return { messageId: message.id, status: "queued" };
+    }
+    ws.send(JSON.stringify({
+      type: "send_sms",
+      messageId: message.id,
+      encryptedPayload
+    }));
+    await db.updateMessage(message.id, {
+      status: RELAY_MESSAGE_STATUS.SENT_TO_DEVICE,
+      sentToDeviceAt: /* @__PURE__ */ new Date()
+    });
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        ackEmitter.removeAllListeners(`ack:${message.id}`);
+        resolve({ messageId: message.id, status: "sent_to_device" });
+      }, timeoutMs);
+      ackEmitter.once(`ack:${message.id}`, (ackStatus) => {
+        clearTimeout(timer);
+        resolve({ messageId: message.id, status: ackStatus });
+      });
+    });
+  }
+  async function handleAck(messageId, status, nativeMessageId, errorMessage) {
+    const updateData = {
+      status: status === "sent" ? RELAY_MESSAGE_STATUS.DELIVERED : RELAY_MESSAGE_STATUS.FAILED,
+      ackedAt: /* @__PURE__ */ new Date()
+    };
+    if (nativeMessageId) updateData.nativeMessageId = nativeMessageId;
+    if (errorMessage) updateData.errorMessage = errorMessage;
+    await db.updateMessage(messageId, updateData);
+    const message = await db.findMessage(messageId).catch(() => null);
+    try {
+      if (message) {
+        if (status === "sent") {
+          await db.incrementRelayStat(message.relayId, "totalSmsSent");
+          await db.incrementRelayStat(message.relayId, "dailySmsSent");
+        } else {
+          await db.incrementRelayStat(message.relayId, "totalSmsFailed");
+        }
+      }
+    } catch (err) {
+      logger.error("Failed to update relay stats after ack", { messageId, error: String(err) });
+    }
+    ackEmitter.emit(`ack:${messageId}`, status);
+    if (message) {
+      if (status === "sent") {
+        events.emit("message:delivered", messageId, message.relayId);
+      } else {
+        events.emit("message:failed", messageId, message.relayId, errorMessage || "Unknown error");
+      }
+    }
+  }
+  async function handleDeliveryReceipt(messageId, deliveryStatus) {
+    await db.updateMessage(messageId, { deliveryStatus });
+  }
+  async function drainQueue(relayId) {
+    const pendingMessages = await db.findPendingMessages(relayId, 50);
+    const ws = getRelaySocket(relayId);
+    if (!ws || ws.readyState !== 1) return;
+    for (const msg of pendingMessages) {
+      ws.send(JSON.stringify({
+        type: "send_sms",
+        messageId: msg.id,
+        encryptedPayload: msg.encryptedPayload
+      }));
+      await db.updateMessage(msg.id, {
+        status: RELAY_MESSAGE_STATUS.SENT_TO_DEVICE,
+        sentToDeviceAt: /* @__PURE__ */ new Date(),
+        attempts: msg.attempts + 1
+      });
+      await new Promise((r) => setTimeout(r, limits.QUEUE_DRAIN_DELAY_MS));
+      if (ws.readyState !== 1) break;
+    }
+  }
+  return { enqueueAndWait, handleAck, handleDeliveryReceipt, drainQueue };
+}
+
+// src/core/crypto/token.ts
+import crypto3 from "crypto";
+function hashToken(token) {
+  return crypto3.createHash("sha256").update(token).digest("hex");
+}
+function generateSecureToken(bytes = 64) {
+  return crypto3.randomBytes(bytes).toString("hex");
+}
+function timingSafeCompare(a, b) {
+  try {
+    return crypto3.timingSafeEqual(Buffer.from(a), Buffer.from(b));
+  } catch {
+    return false;
+  }
+}
+
+// src/errors.ts
+var RelayError = class extends Error {
+  constructor(code, statusCode, message, i18nKey) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.i18nKey = i18nKey;
+    this.name = "RelayError";
+  }
+  /** Safe serialization that never leaks stack traces to clients */
+  toJSON() {
+    return {
+      error: {
+        code: this.code,
+        message: this.message,
+        i18nKey: this.i18nKey
+      }
+    };
+  }
+};
+var RELAY_ERRORS = {
+  RELAY_NOT_FOUND: { code: "RELAY_NOT_FOUND", status: 404, message: "Relay device not found", i18nKey: "errors.relayNotFound" },
+  RELAY_INACTIVE: { code: "RELAY_INACTIVE", status: 409, message: "Relay is not active", i18nKey: "errors.relayInactive" },
+  RELAY_OFFLINE: { code: "RELAY_OFFLINE", status: 503, message: "Relay device is offline", i18nKey: "errors.relayOffline" },
+  PAIRING_NOT_FOUND: { code: "PAIRING_NOT_FOUND", status: 404, message: "Pairing session not found", i18nKey: "errors.pairingNotFound" },
+  PAIRING_EXPIRED: { code: "PAIRING_EXPIRED", status: 410, message: "Pairing session has expired", i18nKey: "errors.pairingExpired" },
+  PAIRING_INVALID_TOKEN: { code: "PAIRING_INVALID_TOKEN", status: 403, message: "Invalid pairing token", i18nKey: "errors.pairingInvalidToken" },
+  AUTH_TIMEOUT: { code: "AUTH_TIMEOUT", status: 408, message: "WebSocket authentication timeout", i18nKey: "errors.authTimeout" },
+  AUTH_FAILED: { code: "AUTH_FAILED", status: 401, message: "Invalid relay credentials", i18nKey: "errors.authFailed" },
+  RATE_LIMITED: { code: "RATE_LIMITED", status: 429, message: "Rate limit exceeded", i18nKey: "errors.rateLimited" },
+  ENCRYPTION_FAILED: { code: "ENCRYPTION_FAILED", status: 500, message: "Encryption operation failed", i18nKey: "errors.encryptionFailed" },
+  REKEY_FAILED: { code: "REKEY_FAILED", status: 500, message: "Key rotation failed", i18nKey: "errors.rekeyFailed" },
+  SMS_SEND_FAILED: { code: "SMS_SEND_FAILED", status: 502, message: "SMS delivery failed", i18nKey: "errors.smsSendFailed" },
+  SMS_TIMEOUT: { code: "SMS_TIMEOUT", status: 504, message: "SMS acknowledgement timeout", i18nKey: "errors.smsTimeout" }
+};
+var RELAY_ERRORS_EXTENDED = {
+  ...RELAY_ERRORS,
+  AUTH_LOCKED: { code: "AUTH_LOCKED", status: 423, message: "Too many failed attempts. Try again later.", i18nKey: "errors.authLocked" },
+  TLS_REQUIRED: { code: "TLS_REQUIRED", status: 426, message: "TLS/SSL connection required", i18nKey: "errors.tlsRequired" },
+  ORG_MISMATCH: { code: "ORG_MISMATCH", status: 403, message: "Organization access denied", i18nKey: "errors.orgMismatch" }
+};
+function createRelayError(key) {
+  const def = RELAY_ERRORS[key];
+  return new RelayError(def.code, def.status, def.message, def.i18nKey);
+}
+
+// src/core/pairing-service.ts
+function createPairingService(deps) {
+  const { db, encryption, logger, limits } = deps;
+  async function initiatePairing(orgId, userId) {
+    await db.deleteExpiredPairings();
+    const { publicKey, privateKey } = generateX25519KeyPair();
+    const pairingToken = generateSecureToken(64);
+    const pairing = await db.createPairing({
+      organizationId: orgId,
+      pairingToken,
+      serverPublicKey: publicKey,
+      serverPrivateKeyEncrypted: encryption.encrypt(privateKey),
+      status: RELAY_PAIRING_STATUS.PENDING,
+      initiatedById: userId,
+      expiresAt: new Date(Date.now() + limits.PAIRING_EXPIRY_MINUTES * 60 * 1e3)
+    });
+    const wsUrl = deps.wsUrl || deps.apiUrl.replace(/^https:/, "wss:").replace(/^http:/, "ws:") + "/ws/relay";
+    return {
+      pairingId: pairing.id,
+      serverPublicKey: publicKey,
+      pairingToken,
+      wsUrl
+    };
+  }
+  async function completePairing(pairingId, pairingToken, devicePublicKey, deviceName, platform, phoneNumber) {
+    const pairing = await db.findPairing(pairingId);
+    if (!pairing) throw createRelayError("PAIRING_NOT_FOUND");
+    if (pairing.status !== RELAY_PAIRING_STATUS.PENDING) throw createRelayError("PAIRING_EXPIRED");
+    if (!timingSafeCompare(pairing.pairingToken, pairingToken)) {
+      throw createRelayError("PAIRING_INVALID_TOKEN");
+    }
+    if (/* @__PURE__ */ new Date() > pairing.expiresAt) {
+      await db.updatePairingStatus(pairingId, RELAY_PAIRING_STATUS.EXPIRED);
+      throw createRelayError("PAIRING_EXPIRED");
+    }
+    const serverPrivateKey = encryption.decrypt(pairing.serverPrivateKeyEncrypted);
+    const sharedKey = deriveSharedKey(serverPrivateKey, devicePublicKey);
+    const authToken = generateSecureToken(64);
+    const authTokenHashed = hashToken(authToken);
+    const relay = await db.createRelay({
+      organizationId: pairing.organizationId,
+      deviceName,
+      platform,
+      phoneNumber: phoneNumber || null,
+      devicePublicKey,
+      sharedKeyEncrypted: encryption.encrypt(sharedKey.toString("hex")),
+      authTokenHash: authTokenHashed,
+      status: "active",
+      lastKeyRotation: null,
+      lastSeenAt: null,
+      lastIpAddress: null,
+      batteryLevel: null,
+      signalStrength: null,
+      dailyResetAt: null,
+      maxSmsPerMinute: limits.MAX_SMS_PER_MINUTE,
+      maxSmsPerHour: limits.MAX_SMS_PER_HOUR,
+      maxSmsPerDay: limits.MAX_SMS_PER_DAY,
+      pairedById: pairing.initiatedById
+    });
+    await db.updatePairingStatus(pairingId, RELAY_PAIRING_STATUS.COMPLETED);
+    try {
+      await deps.onPairingComplete?.({ relayId: relay.id, orgId: pairing.organizationId, deviceName, phoneNumber });
+    } catch (err) {
+      deps.logger.error("onPairingComplete callback failed", { relayId: relay.id, error: String(err) });
+    }
+    return { relayId: relay.id, authToken };
+  }
+  async function revokeRelay(relayId, orgId) {
+    const relay = await db.findRelay(relayId, orgId);
+    if (!relay) throw createRelayError("RELAY_NOT_FOUND");
+    const ws = getRelaySocket(relayId);
+    if (ws) ws.close(1e3, "Relay revoked");
+    await db.deleteMessagesByRelay(relayId);
+    await db.deleteRelay(relayId);
+    try {
+      await deps.onRelayRevoked?.({ relayId, orgId });
+    } catch (err) {
+      deps.logger.error("onRelayRevoked callback failed", { relayId, error: String(err) });
+    }
+  }
+  async function rotateKeys(relayId, orgId) {
+    const relay = await db.findRelay(relayId, orgId);
+    if (!relay) throw createRelayError("RELAY_NOT_FOUND");
+    const ws = getRelaySocket(relayId);
+    if (!ws || ws.readyState !== 1) {
+      throw createRelayError("RELAY_OFFLINE");
+    }
+    const { publicKey, privateKey } = generateX25519KeyPair();
+    ws.send(JSON.stringify({ type: "rekey", serverPublicKey: publicKey }));
+    await db.updateRelay(relayId, {
+      sharedKeyEncrypted: encryption.encrypt(JSON.stringify({
+        pending: true,
+        serverPrivateKey: privateKey,
+        serverPublicKey: publicKey,
+        previousSharedKey: relay.sharedKeyEncrypted
+      }))
+    });
+  }
+  return { initiatePairing, completePairing, revokeRelay, rotateKeys };
+}
+
+// src/core/health-service.ts
+function createHealthService(deps) {
+  const { db, logger, limits } = deps;
+  let healthInterval = null;
+  let dailyResetTimeout = null;
+  let dailyResetInterval = null;
+  let isRunning = false;
+  let isStopped = false;
+  async function runHealthCheck() {
+    if (isRunning || isStopped) {
+      return { expiredMessages: 0, degradedRelays: 0, cleanedPairings: 0 };
+    }
+    isRunning = true;
+    try {
+      const [expiredMessages, cleanedPairings] = await Promise.all([
+        db.expireStaleMessages(),
+        db.deleteExpiredPairings()
+      ]);
+      const threshold = new Date(Date.now() - limits.DEGRADED_THRESHOLD_MS);
+      const degradedRelays = await db.markDegradedRelays(threshold);
+      return { expiredMessages, degradedRelays, cleanedPairings };
+    } finally {
+      isRunning = false;
+    }
+  }
+  function startHealthService() {
+    if (healthInterval) return;
+    healthInterval = setInterval(async () => {
+      try {
+        await runHealthCheck();
+      } catch (err) {
+        logger.error("Relay health service error", { error: String(err) });
+      }
+    }, 6e4);
+    const now = /* @__PURE__ */ new Date();
+    const tomorrow = new Date(now);
+    tomorrow.setUTCDate(tomorrow.getUTCDate() + 1);
+    tomorrow.setUTCHours(0, 0, 0, 0);
+    const msUntilMidnight = tomorrow.getTime() - now.getTime();
+    dailyResetTimeout = setTimeout(() => {
+      db.resetDailyCounters().catch((err) => logger.error("Daily reset failed", { error: String(err) }));
+      dailyResetInterval = setInterval(() => {
+        db.resetDailyCounters().catch((err) => logger.error("Daily reset failed", { error: String(err) }));
+      }, 24 * 60 * 60 * 1e3);
+    }, msUntilMidnight);
+  }
+  function stopHealthService() {
+    isStopped = true;
+    if (healthInterval) {
+      clearInterval(healthInterval);
+      healthInterval = null;
+    }
+    if (dailyResetTimeout) {
+      clearTimeout(dailyResetTimeout);
+      dailyResetTimeout = null;
+    }
+    if (dailyResetInterval) {
+      clearInterval(dailyResetInterval);
+      dailyResetInterval = null;
+    }
+  }
+  return { runHealthCheck, startHealthService, stopHealthService };
+}
+
+// src/core/event-emitter.ts
+import { EventEmitter as EventEmitter2 } from "events";
+var RelayEventEmitter = class {
+  emitter = new EventEmitter2();
+  constructor() {
+    this.emitter.setMaxListeners(1e3);
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return () => {
+      this.emitter.removeListener(event, listener);
+    };
+  }
+  once(event, listener) {
+    this.emitter.once(event, listener);
+  }
+  emit(event, ...args) {
+    this.emitter.emit(event, ...args);
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.emitter.removeAllListeners(event);
+    } else {
+      this.emitter.removeAllListeners();
+    }
+  }
+};
+
+// src/adapters/broadcast.ts
+var NoopBroadcast = class {
+  broadcast(_orgId, _message) {
+  }
+};
+
+// src/adapters/logger.ts
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+  "token",
+  "authToken",
+  "pairingToken",
+  "authTokenHash",
+  "sharedKey",
+  "sharedKeyEncrypted",
+  "privateKey",
+  "serverPrivateKey",
+  "serverPrivateKeyEncrypted",
+  "devicePublicKey",
+  "serverPublicKey",
+  "encryptedPayload",
+  "password",
+  "secret",
+  "credentials",
+  "authorization",
+  "cookie",
+  "body"
+  // SMS body is PII
+]);
+function redact(data) {
+  const safe = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (SENSITIVE_KEYS.has(key) || SENSITIVE_KEYS.has(key.toLowerCase())) {
+      safe[key] = "[REDACTED]";
+    } else if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
+      safe[key] = redact(value);
+    } else {
+      safe[key] = value;
+    }
+  }
+  return safe;
+}
+var ConsoleLogger = class {
+  debug(msg, data) {
+    if (data) console.debug(`[relay-sdk] ${msg}`, redact(data));
+    else console.debug(`[relay-sdk] ${msg}`);
+  }
+  info(msg, data) {
+    if (data) console.info(`[relay-sdk] ${msg}`, redact(data));
+    else console.info(`[relay-sdk] ${msg}`);
+  }
+  warn(msg, data) {
+    if (data) console.warn(`[relay-sdk] ${msg}`, redact(data));
+    else console.warn(`[relay-sdk] ${msg}`);
+  }
+  error(msg, data) {
+    if (data) console.error(`[relay-sdk] ${msg}`, redact(data));
+    else console.error(`[relay-sdk] ${msg}`);
+  }
+};
+function withRedaction(logger) {
+  return {
+    debug: (msg, data) => logger.debug(msg, data ? redact(data) : void 0),
+    info: (msg, data) => logger.info(msg, data ? redact(data) : void 0),
+    warn: (msg, data) => logger.warn(msg, data ? redact(data) : void 0),
+    error: (msg, data) => logger.error(msg, data ? redact(data) : void 0)
+  };
+}
+
+// src/adapters/audit.ts
+var NoopAudit = class {
+  async log(_entry) {
+  }
+};
+var ConsoleAudit = class {
+  async log(entry) {
+    console.info(`[relay-sdk:audit] ${entry.action}`, {
+      timestamp: entry.timestamp.toISOString(),
+      organizationId: entry.organizationId,
+      relayId: entry.relayId,
+      userId: entry.userId,
+      ip: entry.ip,
+      // Never log sensitive metadata values
+      metadata: entry.metadata ? Object.keys(entry.metadata) : void 0
+    });
+  }
+};
+
+// src/providers/phone-relay.ts
+var PhoneRelayProvider = class {
+  name = "phone-relay";
+  relayId = "";
+  orgId = "";
+  queue;
+  constructor(queue) {
+    this.queue = queue;
+  }
+  initialize(credentials) {
+    if (!credentials.relayId) throw new Error("Phone Relay relayId is required");
+    if (!credentials.orgId) throw new Error("Phone Relay orgId is required");
+    this.relayId = credentials.relayId;
+    this.orgId = credentials.orgId;
+  }
+  async sendSms(to, body) {
+    const result = await this.queue.enqueueAndWait({
+      relayId: this.relayId,
+      orgId: this.orgId,
+      to,
+      body
+    });
+    return { messageId: result.messageId, success: result.status !== "failed" };
+  }
+  async validateCredentials(credentials) {
+    return isRelayOnline(credentials.relayId || this.relayId);
+  }
+};
+
+// src/providers/fallback.ts
+var FallbackProvider = class {
+  name = "relay-fallback";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  initialize(_credentials) {
+  }
+  async sendSms(to, body) {
+    if (this.config.isOnline()) {
+      try {
+        const result = await this.config.primary.sendSms(to, body);
+        if (result.success) return result;
+      } catch {
+      }
+    }
+    for (const fb of this.config.fallbacks) {
+      try {
+        const result = await fb.sendSms(to, body);
+        if (result.success) {
+          this.config.onFallback?.(fb.name);
+          return result;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return { success: false };
+  }
+  async validateCredentials(_credentials) {
+    return this.config.isOnline() || this.config.fallbacks.length > 0;
+  }
+};
+
+// src/server/websocket-handler.ts
+var RATE_LIMIT_WINDOW_MS = 1e4;
+var RATE_LIMIT_MAX_MESSAGES = 100;
+function createWebSocketHandler(deps) {
+  const { db, encryption, broadcast, logger, events, queue, limits } = deps;
+  return function handleWebSocket(socket, request) {
+    const log = request.log || logger;
+    let authenticated = false;
+    let relayId = null;
+    let relayOrgId = null;
+    let heartbeatInterval = null;
+    let messageCount = 0;
+    let rateLimitWindowStart = Date.now();
+    const ip = request.ip;
+    log.debug("Relay WebSocket connection opened", { ip });
+    const authTimeout = setTimeout(() => {
+      if (!authenticated) {
+        log.debug("Relay WebSocket auth timeout", { ip });
+        socket.close(4001, "Authentication timeout");
+      }
+    }, limits.AUTH_TIMEOUT_MS);
+    socket.on("message", async (raw) => {
+      const now = Date.now();
+      if (now - rateLimitWindowStart > RATE_LIMIT_WINDOW_MS) {
+        messageCount = 0;
+        rateLimitWindowStart = now;
+      }
+      messageCount++;
+      if (messageCount > RATE_LIMIT_MAX_MESSAGES) {
+        log.warn("Relay WebSocket rate limit exceeded", { relayId, ip });
+        socket.close(4008, "Rate limit exceeded");
+        return;
+      }
+      let message;
+      try {
+        message = JSON.parse(raw.toString());
+      } catch {
+        return;
+      }
+      if (!authenticated) {
+        if (message.type !== RELAY_MESSAGE_TYPES.AUTH) {
+          socket.close(4002, "Must authenticate first");
+          return;
+        }
+        const { relayId: rid, token } = message;
+        if (!rid || !token) {
+          socket.close(4003, "Missing relayId or token");
+          return;
+        }
+        const tokenHash = hashToken(token);
+        const verifiedRelay = await db.findRelayByTokenHash(
+          rid,
+          tokenHash,
+          [RELAY_STATUS.ACTIVE, RELAY_STATUS.DEGRADED]
+        ).catch(() => null);
+        if (!verifiedRelay) {
+          log.warn("Relay WebSocket auth failed", { relayId: rid });
+          socket.close(4004, "Invalid credentials");
+          return;
+        }
+        clearTimeout(authTimeout);
+        authenticated = true;
+        relayId = rid;
+        relayOrgId = verifiedRelay.organizationId;
+        log.debug("Relay WebSocket authenticated", { relayId: rid });
+        const existing = getRelaySocket(rid);
+        if (existing && existing.readyState === 1) {
+          existing.close(4005, "Replaced by new connection");
+        }
+        setRelaySocket(rid, socket);
+        await db.updateRelay(rid, {
+          lastSeenAt: /* @__PURE__ */ new Date(),
+          lastIpAddress: ip,
+          status: RELAY_STATUS.ACTIVE
+        });
+        socket.send(JSON.stringify({ type: "auth_ok" }));
+        broadcast.broadcast(verifiedRelay.organizationId, {
+          type: "relay:status_change",
+          relayId: rid,
+          online: true
+        });
+        events.emit("relay:online", rid, verifiedRelay.organizationId);
+        let pongReceived = true;
+        socket.on("pong", () => {
+          pongReceived = true;
+        });
+        heartbeatInterval = setInterval(() => {
+          if (socket.readyState !== 1) return;
+          if (!pongReceived) {
+            log.warn("Relay pong timeout \u2014 closing stale connection", { relayId: rid });
+            socket.close(1e3, "Pong timeout");
+            return;
+          }
+          pongReceived = false;
+          socket.ping();
+        }, limits.HEARTBEAT_INTERVAL_MS);
+        queue.drainQueue(rid).catch(() => {
+        });
+        return;
+      }
+      const isValidStr = (v, maxLen = 200) => typeof v === "string" && v.length > 0 && v.length <= maxLen;
+      switch (message.type) {
+        case RELAY_MESSAGE_TYPES.SMS_ACK:
+          if (isValidStr(message.messageId)) {
+            const status = isValidStr(message.status, 50) ? message.status : "sent";
+            const nativeId = isValidStr(message.nativeMessageId) ? message.nativeMessageId : void 0;
+            const errorMsg = isValidStr(message.errorMessage, 500) ? message.errorMessage : void 0;
+            log.debug("Relay SMS ACK", { relayId, messageId: message.messageId, status });
+            queue.handleAck(message.messageId, status, nativeId, errorMsg).catch(() => {
+            });
+          }
+          break;
+        case RELAY_MESSAGE_TYPES.DELIVERY_RECEIPT:
+          if (isValidStr(message.messageId) && isValidStr(message.deliveryStatus, 50)) {
+            queue.handleDeliveryReceipt(message.messageId, message.deliveryStatus).catch(() => {
+            });
+          }
+          break;
+        case RELAY_MESSAGE_TYPES.PONG:
+          if (relayId) {
+            db.updateRelay(relayId, { lastSeenAt: /* @__PURE__ */ new Date(), lastIpAddress: ip }).catch(() => {
+            });
+          }
+          break;
+        case RELAY_MESSAGE_TYPES.STATUS:
+          if (relayId) {
+            const battery = typeof message.batteryLevel === "number" && Number.isFinite(message.batteryLevel) ? Math.max(0, Math.min(100, Math.round(message.batteryLevel))) : null;
+            const signal = typeof message.signalStrength === "number" && Number.isFinite(message.signalStrength) ? Math.max(0, Math.min(100, Math.round(message.signalStrength))) : null;
+            const statusUpdate = { lastSeenAt: /* @__PURE__ */ new Date() };
+            if (battery !== null) statusUpdate.batteryLevel = battery;
+            if (signal !== null) statusUpdate.signalStrength = signal;
+            db.updateRelay(relayId, statusUpdate).catch(() => {
+            });
+          }
+          break;
+        case RELAY_MESSAGE_TYPES.REKEY_ACK:
+          if (relayId && isValidStr(message.devicePublicKey, 500)) {
+            try {
+              const relay = await db.findRelay(relayId);
+              if (!relay) break;
+              const rekeyData = JSON.parse(encryption.decrypt(relay.sharedKeyEncrypted));
+              if (!rekeyData.pending) break;
+              const newSharedKey = deriveSharedKey(rekeyData.serverPrivateKey, message.devicePublicKey);
+              await db.updateRelay(relayId, {
+                sharedKeyEncrypted: encryption.encrypt(newSharedKey.toString("hex")),
+                devicePublicKey: message.devicePublicKey,
+                keyVersion: relay.keyVersion + 1,
+                lastKeyRotation: /* @__PURE__ */ new Date()
+              });
+              socket.send(JSON.stringify({ type: "rekey_complete" }));
+            } catch {
+              log.warn("Rekey failed, notifying device", { relayId });
+              socket.send(JSON.stringify({ type: "rekey_failed" }));
+            }
+          }
+          break;
+      }
+    });
+    socket.on("close", async (_code, _reason) => {
+      log.debug("Relay WebSocket connection closed", { relayId: relayId || "unknown" });
+      clearTimeout(authTimeout);
+      if (heartbeatInterval) clearInterval(heartbeatInterval);
+      if (relayId) {
+        deleteRelaySocket(relayId);
+        try {
+          if (relayOrgId) {
+            broadcast.broadcast(relayOrgId, {
+              type: "relay:status_change",
+              relayId,
+              online: false
+            });
+            events.emit("relay:offline", relayId, relayOrgId);
+          } else {
+            const relay = await db.findRelay(relayId);
+            if (relay) {
+              broadcast.broadcast(relay.organizationId, {
+                type: "relay:status_change",
+                relayId,
+                online: false
+              });
+              events.emit("relay:offline", relayId, relay.organizationId);
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    socket.on("error", async () => {
+      clearTimeout(authTimeout);
+      if (heartbeatInterval) clearInterval(heartbeatInterval);
+      if (relayId) {
+        deleteRelaySocket(relayId);
+        try {
+          if (relayOrgId) {
+            broadcast.broadcast(relayOrgId, {
+              type: "relay:status_change",
+              relayId,
+              online: false
+            });
+            events.emit("relay:offline", relayId, relayOrgId);
+          } else {
+            const relay = await db.findRelay(relayId);
+            if (relay) {
+              broadcast.broadcast(relay.organizationId, {
+                type: "relay:status_change",
+                relayId,
+                online: false
+              });
+              events.emit("relay:offline", relayId, relay.organizationId);
+            }
+          }
+        } catch {
+        }
+      }
+    });
+  };
+}
+
+// src/core/auth-limiter.ts
+var AuthLimiter = class {
+  attempts = /* @__PURE__ */ new Map();
+  maxFailures;
+  windowMs;
+  lockoutMs;
+  cleanupInterval;
+  /**
+   * @param maxFailures Max auth failures before lockout (default: 10)
+   * @param windowMs Time window for counting failures in ms (default: 15 min)
+   * @param lockoutMs Duration of lockout after max failures (default: 30 min)
+   */
+  constructor(maxFailures = 10, windowMs = 15 * 60 * 1e3, lockoutMs = 30 * 60 * 1e3) {
+    this.maxFailures = maxFailures;
+    this.windowMs = windowMs;
+    this.lockoutMs = lockoutMs;
+    this.cleanupInterval = setInterval(() => this.cleanup(), 5 * 60 * 1e3);
+  }
+  /** Returns true if the IP is currently locked out */
+  isLocked(ip) {
+    const attempt = this.attempts.get(ip);
+    if (!attempt) return false;
+    if (attempt.lockedUntil > Date.now()) return true;
+    if (attempt.lockedUntil > 0) {
+      this.attempts.delete(ip);
+      return false;
+    }
+    return false;
+  }
+  /** Record a failed auth attempt. Returns remaining attempts before lockout. */
+  recordFailure(ip) {
+    const now = Date.now();
+    let attempt = this.attempts.get(ip);
+    if (!attempt || now - attempt.firstFailure > this.windowMs) {
+      attempt = { failures: 0, firstFailure: now, lockedUntil: 0 };
+    }
+    attempt.failures++;
+    if (attempt.failures >= this.maxFailures) {
+      attempt.lockedUntil = now + this.lockoutMs;
+    }
+    this.attempts.set(ip, attempt);
+    return Math.max(0, this.maxFailures - attempt.failures);
+  }
+  /** Clear failure count for an IP after successful auth */
+  recordSuccess(ip) {
+    this.attempts.delete(ip);
+  }
+  /** Get remaining lockout time in seconds (0 if not locked) */
+  getLockoutRemaining(ip) {
+    const attempt = this.attempts.get(ip);
+    if (!attempt || attempt.lockedUntil <= Date.now()) return 0;
+    return Math.ceil((attempt.lockedUntil - Date.now()) / 1e3);
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [ip, attempt] of this.attempts) {
+      if (attempt.lockedUntil > 0 && attempt.lockedUntil < now) {
+        this.attempts.delete(ip);
+      } else if (now - attempt.firstFailure > this.windowMs && attempt.lockedUntil === 0) {
+        this.attempts.delete(ip);
+      }
+    }
+  }
+  destroy() {
+    clearInterval(this.cleanupInterval);
+    this.attempts.clear();
+  }
+};
+
+// src/schemas.ts
+import { z } from "zod";
+var completePairingSchema = z.object({
+  pairingId: z.string().uuid(),
+  pairingToken: z.string().min(1),
+  devicePublicKey: z.string().min(44).max(5e3),
+  deviceName: z.string().min(1).max(200),
+  platform: z.enum(["android", "ios"]),
+  phoneNumber: z.string().max(30).optional()
+});
+var updatePhoneRelaySchema = z.object({
+  deviceName: z.string().min(1).max(200).optional(),
+  maxSmsPerMinute: z.number().int().min(1).max(60).optional(),
+  maxSmsPerHour: z.number().int().min(1).max(1e3).optional(),
+  maxSmsPerDay: z.number().int().min(1).max(1e4).optional()
+});
+var testRelaySmsSchema = z.object({
+  to: z.string().min(1),
+  body: z.string().min(1).max(160).optional()
+});
+var relayMessagesQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).default(50),
+  offset: z.coerce.number().int().min(0).default(0)
+});
+
+// src/core/crypto/encryption.ts
+import crypto4 from "crypto";
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 12;
+var AUTH_TAG_LENGTH = 16;
+var IV_HEX_LENGTH = IV_LENGTH * 2;
+var AUTH_TAG_HEX_LENGTH = AUTH_TAG_LENGTH * 2;
+var AesGcmEncryption = class {
+  keyBuffer;
+  allowPlaintextFallback;
+  /**
+   * @param key 64-char hex string OR 32-byte Buffer for AES-256
+   * @param options.allowPlaintextFallback Allow decrypting legacy unencrypted values.
+   *   Set to false (default) for PCI DSS v4 compliance. Set to true only during migration.
+   */
+  constructor(key, options) {
+    if (Buffer.isBuffer(key)) {
+      if (key.length !== 32) {
+        throw new Error("Encryption key Buffer must be exactly 32 bytes per PCI DSS v4 Req 3.7.1");
+      }
+      this.keyBuffer = Buffer.from(key);
+      key.fill(0);
+    } else {
+      if (!key || key.length !== 64) {
+        throw new Error(
+          "Encryption key must be exactly 64 hex characters (32 bytes) per PCI DSS v4 Req 3.7.1"
+        );
+      }
+      if (!/^[0-9a-fA-F]+$/.test(key)) {
+        throw new Error("Encryption key must be valid hexadecimal");
+      }
+      this.keyBuffer = Buffer.from(key, "hex");
+    }
+    this.allowPlaintextFallback = options?.allowPlaintextFallback ?? false;
+  }
+  encrypt(plaintext) {
+    const iv = crypto4.randomBytes(IV_LENGTH);
+    const cipher = crypto4.createCipheriv(ALGORITHM, this.keyBuffer, iv);
+    const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+    const authTag = cipher.getAuthTag();
+    return `${iv.toString("hex")}:${authTag.toString("hex")}:${encrypted.toString("hex")}`;
+  }
+  decrypt(ciphertext) {
+    const parts = ciphertext.split(":");
+    if (parts.length !== 3 || parts[0].length !== IV_HEX_LENGTH || parts[1].length !== AUTH_TAG_HEX_LENGTH) {
+      if (this.allowPlaintextFallback) {
+        return ciphertext;
+      }
+      throw new Error(
+        "Invalid ciphertext format. Plaintext fallback is disabled (PCI DSS v4 Req 3.4.1). If migrating legacy data, set allowPlaintextFallback: true temporarily."
+      );
+    }
+    const [ivHex, authTagHex, encryptedHex] = parts;
+    const iv = Buffer.from(ivHex, "hex");
+    const authTag = Buffer.from(authTagHex, "hex");
+    const encrypted = Buffer.from(encryptedHex, "hex");
+    const decipher = crypto4.createDecipheriv(ALGORITHM, this.keyBuffer, iv);
+    decipher.setAuthTag(authTag);
+    try {
+      return decipher.update(encrypted).toString("utf8") + decipher.final("utf8");
+    } catch {
+      throw new Error(
+        "Decryption failed \u2014 possible key rotation issue or data tampering (PCI DSS v4 Req 3.5.1)"
+      );
+    }
+  }
+  /**
+   * Securely destroy the key material (PCI DSS v4 Req 3.5.1).
+   * Call when the SDK instance is being shut down.
+   */
+  destroy() {
+    this.keyBuffer.fill(0);
+  }
+};
+
+// src/adapters/redis-broker.ts
+var RedisBroker = class {
+  pub;
+  // ioredis instance
+  sub;
+  // ioredis instance
+  handlers = /* @__PURE__ */ new Map();
+  prefix;
+  constructor(pubClient, subClient, options) {
+    this.pub = pubClient;
+    this.sub = subClient;
+    this.prefix = options?.prefix ?? "zi2:relay:";
+    this.sub.on("message", (channel, message) => {
+      const handler = this.handlers.get(channel);
+      if (handler) handler(message);
+    });
+  }
+  async publish(channel, message) {
+    await this.pub.publish(`${this.prefix}${channel}`, message);
+  }
+  async subscribe(channel, handler) {
+    const fullChannel = `${this.prefix}${channel}`;
+    this.handlers.set(fullChannel, handler);
+    await this.sub.subscribe(fullChannel);
+  }
+  async unsubscribe(channel) {
+    const fullChannel = `${this.prefix}${channel}`;
+    this.handlers.delete(fullChannel);
+    await this.sub.unsubscribe(fullChannel);
+  }
+  async destroy() {
+    this.handlers.clear();
+    await this.sub.quit();
+    await this.pub.quit();
+  }
+};
+
+// src/adapters/memory-adapter.ts
+var MemoryAdapter = class {
+  relays = /* @__PURE__ */ new Map();
+  pairings = /* @__PURE__ */ new Map();
+  messages = /* @__PURE__ */ new Map();
+  // ── PhoneRelay CRUD ─────────────────────────────────────────────────
+  async findRelay(id, orgId) {
+    const r = this.relays.get(id);
+    if (!r) return null;
+    if (orgId && r.organizationId !== orgId) return null;
+    return structuredClone(r);
+  }
+  async findRelayByTokenHash(id, tokenHash, statuses) {
+    const r = this.relays.get(id);
+    if (!r) return null;
+    if (r.authTokenHash !== tokenHash) return null;
+    if (!statuses.includes(r.status)) return null;
+    return structuredClone(r);
+  }
+  async findRelays(orgId, excludeStatus) {
+    const results = [];
+    for (const r of this.relays.values()) {
+      if (r.organizationId !== orgId) continue;
+      if (excludeStatus && r.status === excludeStatus) continue;
+      results.push(structuredClone(r));
+    }
+    return results.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+  }
+  async createRelay(data) {
+    const now = /* @__PURE__ */ new Date();
+    const record = {
+      id: crypto.randomUUID(),
+      ...data,
+      keyVersion: 1,
+      totalSmsSent: 0,
+      totalSmsFailed: 0,
+      dailySmsSent: 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.relays.set(record.id, record);
+    return structuredClone(record);
+  }
+  async updateRelay(id, data) {
+    const r = this.relays.get(id);
+    if (!r) return;
+    Object.assign(r, data, { updatedAt: /* @__PURE__ */ new Date() });
+  }
+  async updateRelayByOrg(id, orgId, data) {
+    const r = this.relays.get(id);
+    if (!r || r.organizationId !== orgId) return;
+    Object.assign(r, data, { updatedAt: /* @__PURE__ */ new Date() });
+  }
+  async deleteRelay(id) {
+    this.relays.delete(id);
+  }
+  async incrementRelayStat(id, field, amount = 1) {
+    const r = this.relays.get(id);
+    if (!r) return;
+    r[field] += amount;
+    r.updatedAt = /* @__PURE__ */ new Date();
+  }
+  async countRelays(orgId) {
+    let count = 0;
+    for (const r of this.relays.values()) {
+      if (r.organizationId === orgId && r.status !== RELAY_STATUS.REVOKED) {
+        count++;
+      }
+    }
+    return count;
+  }
+  async markDegradedRelays(threshold) {
+    let count = 0;
+    for (const r of this.relays.values()) {
+      if (r.status === RELAY_STATUS.ACTIVE && r.lastSeenAt && r.lastSeenAt < threshold) {
+        r.status = RELAY_STATUS.DEGRADED;
+        r.updatedAt = /* @__PURE__ */ new Date();
+        count++;
+      }
+    }
+    return count;
+  }
+  async resetDailyCounters() {
+    const now = /* @__PURE__ */ new Date();
+    let count = 0;
+    for (const r of this.relays.values()) {
+      if (r.status === RELAY_STATUS.ACTIVE || r.status === RELAY_STATUS.DEGRADED) {
+        r.dailySmsSent = 0;
+        r.dailyResetAt = now;
+        r.updatedAt = now;
+        count++;
+      }
+    }
+    return count;
+  }
+  // ── PhoneRelayPairing ───────────────────────────────────────────────
+  async findPairing(id) {
+    const p = this.pairings.get(id);
+    return p ? structuredClone(p) : null;
+  }
+  async createPairing(data) {
+    const record = {
+      id: crypto.randomUUID(),
+      ...data,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.pairings.set(record.id, record);
+    return structuredClone(record);
+  }
+  async updatePairingStatus(id, status) {
+    const p = this.pairings.get(id);
+    if (p) p.status = status;
+  }
+  async deleteExpiredPairings() {
+    const now = /* @__PURE__ */ new Date();
+    let count = 0;
+    for (const [id, p] of this.pairings) {
+      if (p.expiresAt < now && p.status === "pending") {
+        this.pairings.delete(id);
+        count++;
+      }
+    }
+    return count;
+  }
+  // ── RelayMessageQueue ───────────────────────────────────────────────
+  async findMessage(id) {
+    const m = this.messages.get(id);
+    return m ? structuredClone(m) : null;
+  }
+  async createMessage(data) {
+    const now = /* @__PURE__ */ new Date();
+    const record = {
+      id: crypto.randomUUID(),
+      relayId: data.relayId,
+      organizationId: data.organizationId,
+      encryptedPayload: data.encryptedPayload,
+      status: "pending",
+      attempts: 0,
+      maxAttempts: 3,
+      nativeMessageId: null,
+      errorMessage: null,
+      deliveryStatus: null,
+      sentToDeviceAt: null,
+      ackedAt: null,
+      expiresAt: data.expiresAt,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.messages.set(record.id, record);
+    return structuredClone(record);
+  }
+  async updateMessage(id, data) {
+    const m = this.messages.get(id);
+    if (!m) return;
+    Object.assign(m, data, { updatedAt: /* @__PURE__ */ new Date() });
+  }
+  async findPendingMessages(relayId, limit) {
+    const now = /* @__PURE__ */ new Date();
+    return Array.from(this.messages.values()).filter((m) => m.relayId === relayId && m.status === "pending" && m.expiresAt > now).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime()).slice(0, limit).map((m) => structuredClone(m));
+  }
+  async findMessages(relayId, limit, offset) {
+    const filtered = Array.from(this.messages.values()).filter((m) => m.relayId === relayId).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    const total = filtered.length;
+    const messages = filtered.slice(offset, offset + limit).map((m) => structuredClone(m));
+    return { messages, total };
+  }
+  async deleteMessagesByRelay(relayId) {
+    let count = 0;
+    for (const [id, m] of this.messages) {
+      if (m.relayId === relayId) {
+        this.messages.delete(id);
+        count++;
+      }
+    }
+    return count;
+  }
+  async expireStaleMessages() {
+    const now = /* @__PURE__ */ new Date();
+    let count = 0;
+    for (const m of this.messages.values()) {
+      if (m.expiresAt < now && (m.status === "pending" || m.status === "sent_to_device")) {
+        m.status = "expired";
+        m.updatedAt = /* @__PURE__ */ new Date();
+        count++;
+      }
+    }
+    return count;
+  }
+  // ── Batch operations ────────────────────────────────────────────────
+  async createMessages(batch) {
+    const results = [];
+    for (const data of batch) {
+      results.push(await this.createMessage(data));
+    }
+    return results;
+  }
+  async updateMessages(ids, data) {
+    let count = 0;
+    for (const id of ids) {
+      const m = this.messages.get(id);
+      if (m) {
+        Object.assign(m, data, { updatedAt: /* @__PURE__ */ new Date() });
+        count++;
+      }
+    }
+    return count;
+  }
+  // ── Test helpers ──────────────────────────────────────────────────
+  clear() {
+    this.relays.clear();
+    this.pairings.clear();
+    this.messages.clear();
+  }
+};
+
+// src/i18n/locales/en.ts
+var en = {
+  // Dashboard
+  "relay.title": "ZI2 SMS Relay",
+  "relay.connected": "Connected",
+  "relay.connecting": "Connecting...",
+  "relay.disconnected": "Disconnected",
+  "relay.uptime": "Uptime",
+  "relay.establishingConnection": "Establishing secure connection...",
+  "relay.tapReconnect": "Tap reconnect to retry",
+  "relay.live": "LIVE",
+  "relay.e2eEncrypted": "E2E Encrypted",
+  "relay.reconnect": "Reconnect",
+  "relay.sent": "Sent",
+  "relay.failed": "Failed",
+  "relay.remaining": "Remaining",
+  "relay.successRate": "Success Rate",
+  "relay.thisSession": "this session",
+  "relay.ofPerDay": "of {{limit}}/day",
+  "relay.total": "Total",
+  "relay.dailyUsage": "Daily Usage",
+  "relay.perMin": "{{limit}}/min",
+  "relay.perHr": "{{limit}}/hr",
+  "relay.perDay": "{{limit}}/day",
+  "relay.quickControls": "Quick Controls",
+  "relay.forceReconnect": "Force Reconnect",
+  "relay.forceReconnectDesc": "Re-establish WebSocket connection",
+  "relay.pauseRelay": "Pause Relay",
+  "relay.pauseRelayDesc": "Temporarily stop receiving SMS",
+  "relay.resumeRelay": "Resume Relay",
+  "relay.resumeRelayDesc": "Start receiving SMS again",
+  "relay.sendDeviceStatus": "Send Device Status",
+  "relay.sendDeviceStatusDesc": "Report battery & signal to server",
+  "relay.messageLog": "Message Log",
+  "relay.messagesRecorded": "{{count}} messages recorded",
+  "relay.connectionInfo": "Connection Info",
+  "relay.notPaired": "Not paired",
+  "relay.noServer": "No server",
+  "relay.recentActivity": "Recent Activity",
+  "relay.viewAll": "View All",
+  "relay.noMessagesYet": "No messages yet",
+  "relay.smsWillAppear": "SMS will appear here as they are relayed",
+  "relay.delivered": "Delivered",
+  "relay.smsPermissionRequired": "SMS Permission Required",
+  "relay.smsPermissionDesc": "Grant SMS permission in device settings to send messages",
+  "relay.retry": "Retry",
+  // Pairing
+  "relay.pairingTitle": "ZI2 SMS Relay",
+  "relay.pairingInstruction": "Point the camera at the QR code on your screen to pair.",
+  "relay.pairingWithServer": "Pairing with server...",
+  "relay.pairingFailed": "Pairing failed",
+  "relay.tryAgain": "Try Again",
+  "relay.cameraAccessDenied": "Camera access denied",
+  // Settings
+  "relay.settings": "Settings",
+  "relay.relayInformation": "Relay Information",
+  "relay.relayId": "Relay ID",
+  "relay.server": "Server",
+  "relay.status": "Status",
+  "relay.online": "Online",
+  "relay.offline": "Offline",
+  "relay.encryption": "Encryption",
+  "relay.sessionStatistics": "Session Statistics",
+  "relay.messagesSent": "Messages Sent",
+  "relay.messagesFailed": "Messages Failed",
+  "relay.totalLogged": "Total Logged",
+  "relay.rateLimits": "Rate Limits",
+  "relay.perMinute": "Per Minute",
+  "relay.perHour": "Per Hour",
+  "relay.perDayLabel": "Per Day",
+  "relay.messageExpiry": "Message Expiry",
+  "relay.expiryHours": "{{hours}}h",
+  "relay.about": "About",
+  "relay.version": "ZI2 SMS Relay v1.0.0",
+  "relay.aboutDescription": "Relays SMS messages from your ZI2 server through your phone's native SIM card. All messages are end-to-end encrypted using X25519 key exchange and AES-256-GCM. The server never sees plaintext message content.",
+  "relay.dangerZone": "Danger Zone",
+  "relay.dangerZoneDesc": "Clear all data and unpair this device from the server. This will require re-pairing via QR code.",
+  "relay.clearDataUnpair": "Clear Data & Unpair",
+  "relay.confirmClearData": "Confirm - Clear All Data & Unpair",
+  // Message Log
+  "relay.messageLogTitle": "Message Log",
+  "relay.totalLabel": "total",
+  "relay.all": "All",
+  "relay.noFilteredMessages": "No {{filter}} messages",
+  "relay.messagesWillAppear": "Messages will appear here as SMS are relayed",
+  "relay.sentLabel": "SENT",
+  "relay.failLabel": "FAIL",
+  "relay.e2eFooter": "Message content is E2E encrypted and not stored on device",
+  "relay.copied": "Copied!",
+  "relay.na": "N/A",
+  "relay.cancel": "Cancel",
+  // Error codes
+  "errors.relayNotFound": "Relay device not found",
+  "errors.relayInactive": "Relay is not active",
+  "errors.relayOffline": "Relay device is offline",
+  "errors.pairingNotFound": "Pairing session not found",
+  "errors.pairingExpired": "Pairing session has expired",
+  "errors.pairingInvalidToken": "Invalid pairing token",
+  "errors.authTimeout": "WebSocket authentication timeout",
+  "errors.authFailed": "Invalid relay credentials",
+  "errors.rateLimited": "Rate limit exceeded",
+  "errors.encryptionFailed": "Encryption operation failed",
+  "errors.rekeyFailed": "Key rotation failed",
+  "errors.smsSendFailed": "SMS delivery failed",
+  "errors.smsTimeout": "SMS acknowledgement timeout"
+};
+
+// src/i18n/locales/fr.ts
+var fr = {
+  // Dashboard
+  "relay.title": "ZI2 Relais SMS",
+  "relay.connected": "Connect\xE9",
+  "relay.connecting": "Connexion...",
+  "relay.disconnected": "D\xE9connect\xE9",
+  "relay.uptime": "Disponibilit\xE9",
+  "relay.establishingConnection": "\xC9tablissement de la connexion s\xE9curis\xE9e...",
+  "relay.tapReconnect": "Appuyez sur reconnexion pour r\xE9essayer",
+  "relay.live": "EN DIRECT",
+  "relay.e2eEncrypted": "Chiffrement E2E",
+  "relay.reconnect": "Reconnecter",
+  "relay.sent": "Envoy\xE9s",
+  "relay.failed": "\xC9chou\xE9s",
+  "relay.remaining": "Restants",
+  "relay.successRate": "Taux de r\xE9ussite",
+  "relay.thisSession": "cette session",
+  "relay.ofPerDay": "sur {{limit}}/jour",
+  "relay.total": "Total",
+  "relay.dailyUsage": "Utilisation quotidienne",
+  "relay.perMin": "{{limit}}/min",
+  "relay.perHr": "{{limit}}/h",
+  "relay.perDay": "{{limit}}/jour",
+  "relay.quickControls": "Contr\xF4les rapides",
+  "relay.forceReconnect": "Forcer la reconnexion",
+  "relay.forceReconnectDesc": "R\xE9tablir la connexion WebSocket",
+  "relay.pauseRelay": "Suspendre le relais",
+  "relay.pauseRelayDesc": "Arr\xEAter temporairement la r\xE9ception de SMS",
+  "relay.resumeRelay": "Reprendre le relais",
+  "relay.resumeRelayDesc": "Reprendre la r\xE9ception de SMS",
+  "relay.sendDeviceStatus": "Envoyer l'\xE9tat de l'appareil",
+  "relay.sendDeviceStatusDesc": "Signaler la batterie et le signal au serveur",
+  "relay.messageLog": "Journal des messages",
+  "relay.messagesRecorded": "{{count}} messages enregistr\xE9s",
+  "relay.connectionInfo": "Informations de connexion",
+  "relay.notPaired": "Non appari\xE9",
+  "relay.noServer": "Aucun serveur",
+  "relay.recentActivity": "Activit\xE9 r\xE9cente",
+  "relay.viewAll": "Voir tout",
+  "relay.noMessagesYet": "Aucun message pour le moment",
+  "relay.smsWillAppear": "Les SMS appara\xEEtront ici lorsqu'ils seront relay\xE9s",
+  "relay.delivered": "Livr\xE9",
+  "relay.smsPermissionRequired": "Permission SMS requise",
+  "relay.smsPermissionDesc": "Accordez la permission SMS dans les param\xE8tres de l'appareil pour envoyer des messages",
+  "relay.retry": "R\xE9essayer",
+  // Pairing
+  "relay.pairingTitle": "ZI2 Relais SMS",
+  "relay.pairingInstruction": "Pointez la cam\xE9ra vers le code QR sur votre \xE9cran pour appairer.",
+  "relay.pairingWithServer": "Appairage avec le serveur...",
+  "relay.pairingFailed": "\xC9chec de l'appairage",
+  "relay.tryAgain": "R\xE9essayer",
+  "relay.cameraAccessDenied": "Acc\xE8s \xE0 la cam\xE9ra refus\xE9",
+  // Settings
+  "relay.settings": "Param\xE8tres",
+  "relay.relayInformation": "Informations du relais",
+  "relay.relayId": "ID du relais",
+  "relay.server": "Serveur",
+  "relay.status": "Statut",
+  "relay.online": "En ligne",
+  "relay.offline": "Hors ligne",
+  "relay.encryption": "Chiffrement",
+  "relay.sessionStatistics": "Statistiques de session",
+  "relay.messagesSent": "Messages envoy\xE9s",
+  "relay.messagesFailed": "Messages \xE9chou\xE9s",
+  "relay.totalLogged": "Total enregistr\xE9",
+  "relay.rateLimits": "Limites de d\xE9bit",
+  "relay.perMinute": "Par minute",
+  "relay.perHour": "Par heure",
+  "relay.perDayLabel": "Par jour",
+  "relay.messageExpiry": "Expiration des messages",
+  "relay.expiryHours": "{{hours}}h",
+  "relay.about": "\xC0 propos",
+  "relay.version": "ZI2 Relais SMS v1.0.0",
+  "relay.aboutDescription": "Relaye les messages SMS depuis votre serveur ZI2 via la carte SIM native de votre t\xE9l\xE9phone. Tous les messages sont chiffr\xE9s de bout en bout avec l'\xE9change de cl\xE9s X25519 et AES-256-GCM. Le serveur ne voit jamais le contenu en clair des messages.",
+  "relay.dangerZone": "Zone de danger",
+  "relay.dangerZoneDesc": "Effacer toutes les donn\xE9es et d\xE9sappairer cet appareil du serveur. Cela n\xE9cessitera un r\xE9-appairage via code QR.",
+  "relay.clearDataUnpair": "Effacer les donn\xE9es et d\xE9sappairer",
+  "relay.confirmClearData": "Confirmer - Effacer toutes les donn\xE9es et d\xE9sappairer",
+  // Message Log
+  "relay.messageLogTitle": "Journal des messages",
+  "relay.totalLabel": "total",
+  "relay.all": "Tous",
+  "relay.noFilteredMessages": "Aucun message {{filter}}",
+  "relay.messagesWillAppear": "Les messages appara\xEEtront ici lorsque les SMS seront relay\xE9s",
+  "relay.sentLabel": "ENVOY\xC9",
+  "relay.failLabel": "\xC9CHEC",
+  "relay.e2eFooter": "Le contenu des messages est chiffr\xE9 E2E et non stock\xE9 sur l'appareil",
+  "relay.copied": "Copi\xE9 !",
+  "relay.na": "N/A",
+  "relay.cancel": "Annuler",
+  // Error codes
+  "errors.relayNotFound": "Appareil relais introuvable",
+  "errors.relayInactive": "Le relais n'est pas actif",
+  "errors.relayOffline": "L'appareil relais est hors ligne",
+  "errors.pairingNotFound": "Session d'appairage introuvable",
+  "errors.pairingExpired": "La session d'appairage a expir\xE9",
+  "errors.pairingInvalidToken": "Jeton d'appairage invalide",
+  "errors.authTimeout": "D\xE9lai d'authentification WebSocket d\xE9pass\xE9",
+  "errors.authFailed": "Identifiants du relais invalides",
+  "errors.rateLimited": "Limite de d\xE9bit d\xE9pass\xE9e",
+  "errors.encryptionFailed": "\xC9chec de l'op\xE9ration de chiffrement",
+  "errors.rekeyFailed": "\xC9chec de la rotation des cl\xE9s",
+  "errors.smsSendFailed": "\xC9chec de la livraison du SMS",
+  "errors.smsTimeout": "D\xE9lai d'accus\xE9 de r\xE9ception du SMS d\xE9pass\xE9"
+};
+
+// src/i18n/locales/es.ts
+var es = {
+  // Dashboard
+  "relay.title": "ZI2 Rel\xE9 SMS",
+  "relay.connected": "Conectado",
+  "relay.connecting": "Conectando...",
+  "relay.disconnected": "Desconectado",
+  "relay.uptime": "Tiempo activo",
+  "relay.establishingConnection": "Estableciendo conexi\xF3n segura...",
+  "relay.tapReconnect": "Toque reconectar para reintentar",
+  "relay.live": "EN VIVO",
+  "relay.e2eEncrypted": "Cifrado E2E",
+  "relay.reconnect": "Reconectar",
+  "relay.sent": "Enviados",
+  "relay.failed": "Fallidos",
+  "relay.remaining": "Restantes",
+  "relay.successRate": "Tasa de \xE9xito",
+  "relay.thisSession": "esta sesi\xF3n",
+  "relay.ofPerDay": "de {{limit}}/d\xEDa",
+  "relay.total": "Total",
+  "relay.dailyUsage": "Uso diario",
+  "relay.perMin": "{{limit}}/min",
+  "relay.perHr": "{{limit}}/h",
+  "relay.perDay": "{{limit}}/d\xEDa",
+  "relay.quickControls": "Controles r\xE1pidos",
+  "relay.forceReconnect": "Forzar reconexi\xF3n",
+  "relay.forceReconnectDesc": "Restablecer la conexi\xF3n WebSocket",
+  "relay.pauseRelay": "Pausar rel\xE9",
+  "relay.pauseRelayDesc": "Dejar de recibir SMS temporalmente",
+  "relay.resumeRelay": "Reanudar rel\xE9",
+  "relay.resumeRelayDesc": "Volver a recibir SMS",
+  "relay.sendDeviceStatus": "Enviar estado del dispositivo",
+  "relay.sendDeviceStatusDesc": "Informar bater\xEDa y se\xF1al al servidor",
+  "relay.messageLog": "Registro de mensajes",
+  "relay.messagesRecorded": "{{count}} mensajes registrados",
+  "relay.connectionInfo": "Informaci\xF3n de conexi\xF3n",
+  "relay.notPaired": "No emparejado",
+  "relay.noServer": "Sin servidor",
+  "relay.recentActivity": "Actividad reciente",
+  "relay.viewAll": "Ver todo",
+  "relay.noMessagesYet": "Sin mensajes a\xFAn",
+  "relay.smsWillAppear": "Los SMS aparecer\xE1n aqu\xED cuando sean retransmitidos",
+  "relay.delivered": "Entregado",
+  "relay.smsPermissionRequired": "Permiso de SMS requerido",
+  "relay.smsPermissionDesc": "Otorgue permiso de SMS en la configuraci\xF3n del dispositivo para enviar mensajes",
+  "relay.retry": "Reintentar",
+  // Pairing
+  "relay.pairingTitle": "ZI2 Rel\xE9 SMS",
+  "relay.pairingInstruction": "Apunte la c\xE1mara al c\xF3digo QR en su pantalla para emparejar.",
+  "relay.pairingWithServer": "Emparejando con el servidor...",
+  "relay.pairingFailed": "Error en el emparejamiento",
+  "relay.tryAgain": "Intentar de nuevo",
+  "relay.cameraAccessDenied": "Acceso a la c\xE1mara denegado",
+  // Settings
+  "relay.settings": "Configuraci\xF3n",
+  "relay.relayInformation": "Informaci\xF3n del rel\xE9",
+  "relay.relayId": "ID del rel\xE9",
+  "relay.server": "Servidor",
+  "relay.status": "Estado",
+  "relay.online": "En l\xEDnea",
+  "relay.offline": "Fuera de l\xEDnea",
+  "relay.encryption": "Cifrado",
+  "relay.sessionStatistics": "Estad\xEDsticas de sesi\xF3n",
+  "relay.messagesSent": "Mensajes enviados",
+  "relay.messagesFailed": "Mensajes fallidos",
+  "relay.totalLogged": "Total registrado",
+  "relay.rateLimits": "L\xEDmites de velocidad",
+  "relay.perMinute": "Por minuto",
+  "relay.perHour": "Por hora",
+  "relay.perDayLabel": "Por d\xEDa",
+  "relay.messageExpiry": "Expiraci\xF3n de mensajes",
+  "relay.expiryHours": "{{hours}}h",
+  "relay.about": "Acerca de",
+  "relay.version": "ZI2 Rel\xE9 SMS v1.0.0",
+  "relay.aboutDescription": "Retransmite mensajes SMS desde su servidor ZI2 a trav\xE9s de la tarjeta SIM nativa de su tel\xE9fono. Todos los mensajes est\xE1n cifrados de extremo a extremo usando intercambio de claves X25519 y AES-256-GCM.",
+  "relay.dangerZone": "Zona de peligro",
+  "relay.dangerZoneDesc": "Borrar todos los datos y desemparejar este dispositivo del servidor. Esto requerir\xE1 un nuevo emparejamiento v\xEDa c\xF3digo QR.",
+  "relay.clearDataUnpair": "Borrar datos y desemparejar",
+  "relay.confirmClearData": "Confirmar - Borrar todos los datos y desemparejar",
+  // Message Log
+  "relay.messageLogTitle": "Registro de mensajes",
+  "relay.totalLabel": "total",
+  "relay.all": "Todos",
+  "relay.noFilteredMessages": "Sin mensajes {{filter}}",
+  "relay.messagesWillAppear": "Los mensajes aparecer\xE1n aqu\xED cuando los SMS sean retransmitidos",
+  "relay.sentLabel": "ENVIADO",
+  "relay.failLabel": "FALLO",
+  "relay.e2eFooter": "El contenido del mensaje est\xE1 cifrado E2E y no se almacena en el dispositivo",
+  "relay.copied": "\xA1Copiado!",
+  "relay.na": "N/A",
+  "relay.cancel": "Cancelar",
+  // Error codes
+  "errors.relayNotFound": "Dispositivo rel\xE9 no encontrado",
+  "errors.relayInactive": "El rel\xE9 no est\xE1 activo",
+  "errors.relayOffline": "El dispositivo rel\xE9 est\xE1 fuera de l\xEDnea",
+  "errors.pairingNotFound": "Sesi\xF3n de emparejamiento no encontrada",
+  "errors.pairingExpired": "La sesi\xF3n de emparejamiento ha expirado",
+  "errors.pairingInvalidToken": "Token de emparejamiento inv\xE1lido",
+  "errors.authTimeout": "Tiempo de autenticaci\xF3n WebSocket agotado",
+  "errors.authFailed": "Credenciales del rel\xE9 inv\xE1lidas",
+  "errors.rateLimited": "L\xEDmite de velocidad excedido",
+  "errors.encryptionFailed": "Error en la operaci\xF3n de cifrado",
+  "errors.rekeyFailed": "Error en la rotaci\xF3n de claves",
+  "errors.smsSendFailed": "Error en la entrega del SMS",
+  "errors.smsTimeout": "Tiempo de acuse de recibo del SMS agotado"
+};
+
+// src/i18n/locales/de.ts
+var de = {
+  // Dashboard
+  "relay.title": "ZI2 SMS-Relay",
+  "relay.connected": "Verbunden",
+  "relay.connecting": "Verbindung wird hergestellt...",
+  "relay.disconnected": "Getrennt",
+  "relay.uptime": "Betriebszeit",
+  "relay.establishingConnection": "Sichere Verbindung wird hergestellt...",
+  "relay.tapReconnect": "Tippen Sie auf Verbinden, um es erneut zu versuchen",
+  "relay.live": "LIVE",
+  "relay.e2eEncrypted": "E2E-verschl\xFCsselt",
+  "relay.reconnect": "Neu verbinden",
+  "relay.sent": "Gesendet",
+  "relay.failed": "Fehlgeschlagen",
+  "relay.remaining": "Verbleibend",
+  "relay.successRate": "Erfolgsrate",
+  "relay.thisSession": "diese Sitzung",
+  "relay.ofPerDay": "von {{limit}}/Tag",
+  "relay.total": "Gesamt",
+  "relay.dailyUsage": "T\xE4gliche Nutzung",
+  "relay.perMin": "{{limit}}/min",
+  "relay.perHr": "{{limit}}/Std",
+  "relay.perDay": "{{limit}}/Tag",
+  "relay.quickControls": "Schnellsteuerung",
+  "relay.forceReconnect": "Verbindung erzwingen",
+  "relay.forceReconnectDesc": "WebSocket-Verbindung wiederherstellen",
+  "relay.pauseRelay": "Relay pausieren",
+  "relay.pauseRelayDesc": "SMS-Empfang vor\xFCbergehend stoppen",
+  "relay.resumeRelay": "Relay fortsetzen",
+  "relay.resumeRelayDesc": "SMS-Empfang wieder aufnehmen",
+  "relay.sendDeviceStatus": "Ger\xE4testatus senden",
+  "relay.sendDeviceStatusDesc": "Akku und Signal an Server melden",
+  "relay.messageLog": "Nachrichtenprotokoll",
+  "relay.messagesRecorded": "{{count}} Nachrichten aufgezeichnet",
+  "relay.connectionInfo": "Verbindungsinformationen",
+  "relay.notPaired": "Nicht gekoppelt",
+  "relay.noServer": "Kein Server",
+  "relay.recentActivity": "Letzte Aktivit\xE4t",
+  "relay.viewAll": "Alle anzeigen",
+  "relay.noMessagesYet": "Noch keine Nachrichten",
+  "relay.smsWillAppear": "SMS werden hier angezeigt, wenn sie weitergeleitet werden",
+  "relay.delivered": "Zugestellt",
+  "relay.smsPermissionRequired": "SMS-Berechtigung erforderlich",
+  "relay.smsPermissionDesc": "Erteilen Sie die SMS-Berechtigung in den Ger\xE4teeinstellungen, um Nachrichten zu senden",
+  "relay.retry": "Erneut versuchen",
+  // Pairing
+  "relay.pairingTitle": "ZI2 SMS-Relay",
+  "relay.pairingInstruction": "Richten Sie die Kamera auf den QR-Code auf Ihrem Bildschirm, um zu koppeln.",
+  "relay.pairingWithServer": "Kopplung mit Server...",
+  "relay.pairingFailed": "Kopplung fehlgeschlagen",
+  "relay.tryAgain": "Erneut versuchen",
+  "relay.cameraAccessDenied": "Kamerazugriff verweigert",
+  // Settings
+  "relay.settings": "Einstellungen",
+  "relay.relayInformation": "Relay-Informationen",
+  "relay.relayId": "Relay-ID",
+  "relay.server": "Server",
+  "relay.status": "Status",
+  "relay.online": "Online",
+  "relay.offline": "Offline",
+  "relay.encryption": "Verschl\xFCsselung",
+  "relay.sessionStatistics": "Sitzungsstatistiken",
+  "relay.messagesSent": "Gesendete Nachrichten",
+  "relay.messagesFailed": "Fehlgeschlagene Nachrichten",
+  "relay.totalLogged": "Gesamt protokolliert",
+  "relay.rateLimits": "Ratenbegrenzungen",
+  "relay.perMinute": "Pro Minute",
+  "relay.perHour": "Pro Stunde",
+  "relay.perDayLabel": "Pro Tag",
+  "relay.messageExpiry": "Nachrichtenablauf",
+  "relay.expiryHours": "{{hours}}h",
+  "relay.about": "\xDCber",
+  "relay.version": "ZI2 SMS-Relay v1.0.0",
+  "relay.aboutDescription": "Leitet SMS-Nachrichten von Ihrem ZI2-Server \xFCber die native SIM-Karte Ihres Telefons weiter. Alle Nachrichten sind Ende-zu-Ende mit X25519-Schl\xFCsselaustausch und AES-256-GCM verschl\xFCsselt.",
+  "relay.dangerZone": "Gefahrenzone",
+  "relay.dangerZoneDesc": "Alle Daten l\xF6schen und dieses Ger\xE4t vom Server entkoppeln. Dies erfordert eine erneute Kopplung \xFCber QR-Code.",
+  "relay.clearDataUnpair": "Daten l\xF6schen & entkoppeln",
+  "relay.confirmClearData": "Best\xE4tigen - Alle Daten l\xF6schen & entkoppeln",
+  // Message Log
+  "relay.messageLogTitle": "Nachrichtenprotokoll",
+  "relay.totalLabel": "gesamt",
+  "relay.all": "Alle",
+  "relay.noFilteredMessages": "Keine {{filter}} Nachrichten",
+  "relay.messagesWillAppear": "Nachrichten erscheinen hier, wenn SMS weitergeleitet werden",
+  "relay.sentLabel": "GESENDET",
+  "relay.failLabel": "FEHLER",
+  "relay.e2eFooter": "Nachrichteninhalt ist E2E-verschl\xFCsselt und wird nicht auf dem Ger\xE4t gespeichert",
+  "relay.copied": "Kopiert!",
+  "relay.na": "N/A",
+  "relay.cancel": "Abbrechen",
+  // Error codes
+  "errors.relayNotFound": "Relay-Ger\xE4t nicht gefunden",
+  "errors.relayInactive": "Relay ist nicht aktiv",
+  "errors.relayOffline": "Relay-Ger\xE4t ist offline",
+  "errors.pairingNotFound": "Kopplungssitzung nicht gefunden",
+  "errors.pairingExpired": "Kopplungssitzung ist abgelaufen",
+  "errors.pairingInvalidToken": "Ung\xFCltiges Kopplungstoken",
+  "errors.authTimeout": "WebSocket-Authentifizierungszeit\xFCberschreitung",
+  "errors.authFailed": "Ung\xFCltige Relay-Anmeldedaten",
+  "errors.rateLimited": "Ratenbegrenzung \xFCberschritten",
+  "errors.encryptionFailed": "Verschl\xFCsselungsvorgang fehlgeschlagen",
+  "errors.rekeyFailed": "Schl\xFCsselrotation fehlgeschlagen",
+  "errors.smsSendFailed": "SMS-Zustellung fehlgeschlagen",
+  "errors.smsTimeout": "SMS-Best\xE4tigungszeit\xFCberschreitung"
+};
+
+// src/i18n/locales/ja.ts
+var ja = {
+  // Dashboard
+  "relay.title": "ZI2 SMS\u30EA\u30EC\u30FC",
+  "relay.connected": "\u63A5\u7D9A\u6E08\u307F",
+  "relay.connecting": "\u63A5\u7D9A\u4E2D...",
+  "relay.disconnected": "\u5207\u65AD\u6E08\u307F",
+  "relay.uptime": "\u7A3C\u50CD\u6642\u9593",
+  "relay.establishingConnection": "\u5B89\u5168\u306A\u63A5\u7D9A\u3092\u78BA\u7ACB\u4E2D...",
+  "relay.tapReconnect": "\u518D\u63A5\u7D9A\u3092\u30BF\u30C3\u30D7\u3057\u3066\u30EA\u30C8\u30E9\u30A4",
+  "relay.live": "\u30E9\u30A4\u30D6",
+  "relay.e2eEncrypted": "E2E\u6697\u53F7\u5316",
+  "relay.reconnect": "\u518D\u63A5\u7D9A",
+  "relay.sent": "\u9001\u4FE1\u6E08\u307F",
+  "relay.failed": "\u5931\u6557",
+  "relay.remaining": "\u6B8B\u308A",
+  "relay.successRate": "\u6210\u529F\u7387",
+  "relay.thisSession": "\u4ECA\u56DE\u306E\u30BB\u30C3\u30B7\u30E7\u30F3",
+  "relay.ofPerDay": "{{limit}}/\u65E5\u306E\u3046\u3061",
+  "relay.total": "\u5408\u8A08",
+  "relay.dailyUsage": "\u65E5\u6B21\u4F7F\u7528\u91CF",
+  "relay.perMin": "{{limit}}/\u5206",
+  "relay.perHr": "{{limit}}/\u6642",
+  "relay.perDay": "{{limit}}/\u65E5",
+  "relay.quickControls": "\u30AF\u30A4\u30C3\u30AF\u30B3\u30F3\u30C8\u30ED\u30FC\u30EB",
+  "relay.forceReconnect": "\u5F37\u5236\u518D\u63A5\u7D9A",
+  "relay.forceReconnectDesc": "WebSocket\u63A5\u7D9A\u3092\u518D\u78BA\u7ACB",
+  "relay.pauseRelay": "\u30EA\u30EC\u30FC\u3092\u4E00\u6642\u505C\u6B62",
+  "relay.pauseRelayDesc": "SMS\u53D7\u4FE1\u3092\u4E00\u6642\u7684\u306B\u505C\u6B62",
+  "relay.resumeRelay": "\u30EA\u30EC\u30FC\u3092\u518D\u958B",
+  "relay.resumeRelayDesc": "SMS\u53D7\u4FE1\u3092\u518D\u958B",
+  "relay.sendDeviceStatus": "\u30C7\u30D0\u30A4\u30B9\u30B9\u30C6\u30FC\u30BF\u30B9\u3092\u9001\u4FE1",
+  "relay.sendDeviceStatusDesc": "\u30D0\u30C3\u30C6\u30EA\u30FC\u3068\u96FB\u6CE2\u3092\u30B5\u30FC\u30D0\u30FC\u306B\u5831\u544A",
+  "relay.messageLog": "\u30E1\u30C3\u30BB\u30FC\u30B8\u30ED\u30B0",
+  "relay.messagesRecorded": "{{count}}\u4EF6\u306E\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u8A18\u9332",
+  "relay.connectionInfo": "\u63A5\u7D9A\u60C5\u5831",
+  "relay.notPaired": "\u672A\u30DA\u30A2\u30EA\u30F3\u30B0",
+  "relay.noServer": "\u30B5\u30FC\u30D0\u30FC\u306A\u3057",
+  "relay.recentActivity": "\u6700\u8FD1\u306E\u30A2\u30AF\u30C6\u30A3\u30D3\u30C6\u30A3",
+  "relay.viewAll": "\u3059\u3079\u3066\u8868\u793A",
+  "relay.noMessagesYet": "\u30E1\u30C3\u30BB\u30FC\u30B8\u306F\u307E\u3060\u3042\u308A\u307E\u305B\u3093",
+  "relay.smsWillAppear": "\u30EA\u30EC\u30FC\u3055\u308C\u305FSMS\u304C\u3053\u3053\u306B\u8868\u793A\u3055\u308C\u307E\u3059",
+  "relay.delivered": "\u914D\u4FE1\u6E08\u307F",
+  "relay.smsPermissionRequired": "SMS\u6A29\u9650\u304C\u5FC5\u8981",
+  "relay.smsPermissionDesc": "\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u9001\u4FE1\u3059\u308B\u306B\u306F\u30C7\u30D0\u30A4\u30B9\u8A2D\u5B9A\u3067SMS\u6A29\u9650\u3092\u8A31\u53EF\u3057\u3066\u304F\u3060\u3055\u3044",
+  "relay.retry": "\u30EA\u30C8\u30E9\u30A4",
+  // Pairing
+  "relay.pairingTitle": "ZI2 SMS\u30EA\u30EC\u30FC",
+  "relay.pairingInstruction": "\u753B\u9762\u306EQR\u30B3\u30FC\u30C9\u306B\u30AB\u30E1\u30E9\u3092\u5411\u3051\u3066\u30DA\u30A2\u30EA\u30F3\u30B0\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+  "relay.pairingWithServer": "\u30B5\u30FC\u30D0\u30FC\u3068\u30DA\u30A2\u30EA\u30F3\u30B0\u4E2D...",
+  "relay.pairingFailed": "\u30DA\u30A2\u30EA\u30F3\u30B0\u5931\u6557",
+  "relay.tryAgain": "\u518D\u8A66\u884C",
+  "relay.cameraAccessDenied": "\u30AB\u30E1\u30E9\u30A2\u30AF\u30BB\u30B9\u304C\u62D2\u5426\u3055\u308C\u307E\u3057\u305F",
+  // Settings
+  "relay.settings": "\u8A2D\u5B9A",
+  "relay.relayInformation": "\u30EA\u30EC\u30FC\u60C5\u5831",
+  "relay.relayId": "\u30EA\u30EC\u30FCID",
+  "relay.server": "\u30B5\u30FC\u30D0\u30FC",
+  "relay.status": "\u30B9\u30C6\u30FC\u30BF\u30B9",
+  "relay.online": "\u30AA\u30F3\u30E9\u30A4\u30F3",
+  "relay.offline": "\u30AA\u30D5\u30E9\u30A4\u30F3",
+  "relay.encryption": "\u6697\u53F7\u5316",
+  "relay.sessionStatistics": "\u30BB\u30C3\u30B7\u30E7\u30F3\u7D71\u8A08",
+  "relay.messagesSent": "\u9001\u4FE1\u30E1\u30C3\u30BB\u30FC\u30B8",
+  "relay.messagesFailed": "\u5931\u6557\u30E1\u30C3\u30BB\u30FC\u30B8",
+  "relay.totalLogged": "\u5408\u8A08\u30ED\u30B0",
+  "relay.rateLimits": "\u30EC\u30FC\u30C8\u5236\u9650",
+  "relay.perMinute": "\u6BCE\u5206",
+  "relay.perHour": "\u6BCE\u6642",
+  "relay.perDayLabel": "\u6BCE\u65E5",
+  "relay.messageExpiry": "\u30E1\u30C3\u30BB\u30FC\u30B8\u6709\u52B9\u671F\u9650",
+  "relay.expiryHours": "{{hours}}\u6642\u9593",
+  "relay.about": "\u30D0\u30FC\u30B8\u30E7\u30F3\u60C5\u5831",
+  "relay.version": "ZI2 SMS\u30EA\u30EC\u30FC v1.0.0",
+  "relay.aboutDescription": "ZI2\u30B5\u30FC\u30D0\u30FC\u304B\u3089\u306ESMS\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u304A\u4F7F\u3044\u306E\u643A\u5E2F\u96FB\u8A71\u306E\u30CD\u30A4\u30C6\u30A3\u30D6SIM\u30AB\u30FC\u30C9\u3092\u901A\u3058\u3066\u30EA\u30EC\u30FC\u3057\u307E\u3059\u3002\u3059\u3079\u3066\u306E\u30E1\u30C3\u30BB\u30FC\u30B8\u306FX25519\u9375\u4EA4\u63DB\u3068AES-256-GCM\u3067\u7AEF\u672B\u9593\u6697\u53F7\u5316\u3055\u308C\u3066\u3044\u307E\u3059\u3002",
+  "relay.dangerZone": "\u5371\u967A\u30BE\u30FC\u30F3",
+  "relay.dangerZoneDesc": "\u3059\u3079\u3066\u306E\u30C7\u30FC\u30BF\u3092\u6D88\u53BB\u3057\u3001\u3053\u306E\u30C7\u30D0\u30A4\u30B9\u3092\u30B5\u30FC\u30D0\u30FC\u304B\u3089\u30DA\u30A2\u30EA\u30F3\u30B0\u89E3\u9664\u3057\u307E\u3059\u3002QR\u30B3\u30FC\u30C9\u3067\u306E\u518D\u30DA\u30A2\u30EA\u30F3\u30B0\u304C\u5FC5\u8981\u306B\u306A\u308A\u307E\u3059\u3002",
+  "relay.clearDataUnpair": "\u30C7\u30FC\u30BF\u6D88\u53BB\uFF06\u30DA\u30A2\u30EA\u30F3\u30B0\u89E3\u9664",
+  "relay.confirmClearData": "\u78BA\u8A8D - \u3059\u3079\u3066\u306E\u30C7\u30FC\u30BF\u3092\u6D88\u53BB\uFF06\u30DA\u30A2\u30EA\u30F3\u30B0\u89E3\u9664",
+  // Message Log
+  "relay.messageLogTitle": "\u30E1\u30C3\u30BB\u30FC\u30B8\u30ED\u30B0",
+  "relay.totalLabel": "\u5408\u8A08",
+  "relay.all": "\u3059\u3079\u3066",
+  "relay.noFilteredMessages": "{{filter}}\u30E1\u30C3\u30BB\u30FC\u30B8\u306F\u3042\u308A\u307E\u305B\u3093",
+  "relay.messagesWillAppear": "SMS\u304C\u30EA\u30EC\u30FC\u3055\u308C\u308B\u3068\u3053\u3053\u306B\u30E1\u30C3\u30BB\u30FC\u30B8\u304C\u8868\u793A\u3055\u308C\u307E\u3059",
+  "relay.sentLabel": "\u9001\u4FE1",
+  "relay.failLabel": "\u5931\u6557",
+  "relay.e2eFooter": "\u30E1\u30C3\u30BB\u30FC\u30B8\u5185\u5BB9\u306FE2E\u6697\u53F7\u5316\u3055\u308C\u30C7\u30D0\u30A4\u30B9\u306B\u306F\u4FDD\u5B58\u3055\u308C\u307E\u305B\u3093",
+  "relay.copied": "\u30B3\u30D4\u30FC\u3057\u307E\u3057\u305F\uFF01",
+  "relay.na": "N/A",
+  "relay.cancel": "\u30AD\u30E3\u30F3\u30BB\u30EB",
+  // Error codes
+  "errors.relayNotFound": "\u30EA\u30EC\u30FC\u30C7\u30D0\u30A4\u30B9\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093",
+  "errors.relayInactive": "\u30EA\u30EC\u30FC\u306F\u30A2\u30AF\u30C6\u30A3\u30D6\u3067\u306F\u3042\u308A\u307E\u305B\u3093",
+  "errors.relayOffline": "\u30EA\u30EC\u30FC\u30C7\u30D0\u30A4\u30B9\u306F\u30AA\u30D5\u30E9\u30A4\u30F3\u3067\u3059",
+  "errors.pairingNotFound": "\u30DA\u30A2\u30EA\u30F3\u30B0\u30BB\u30C3\u30B7\u30E7\u30F3\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093",
+  "errors.pairingExpired": "\u30DA\u30A2\u30EA\u30F3\u30B0\u30BB\u30C3\u30B7\u30E7\u30F3\u306E\u6709\u52B9\u671F\u9650\u304C\u5207\u308C\u3066\u3044\u307E\u3059",
+  "errors.pairingInvalidToken": "\u7121\u52B9\u306A\u30DA\u30A2\u30EA\u30F3\u30B0\u30C8\u30FC\u30AF\u30F3",
+  "errors.authTimeout": "WebSocket\u8A8D\u8A3C\u30BF\u30A4\u30E0\u30A2\u30A6\u30C8",
+  "errors.authFailed": "\u7121\u52B9\u306A\u30EA\u30EC\u30FC\u8A8D\u8A3C\u60C5\u5831",
+  "errors.rateLimited": "\u30EC\u30FC\u30C8\u5236\u9650\u3092\u8D85\u904E",
+  "errors.encryptionFailed": "\u6697\u53F7\u5316\u64CD\u4F5C\u306B\u5931\u6557",
+  "errors.rekeyFailed": "\u9375\u30ED\u30FC\u30C6\u30FC\u30B7\u30E7\u30F3\u306B\u5931\u6557",
+  "errors.smsSendFailed": "SMS\u914D\u4FE1\u306B\u5931\u6557",
+  "errors.smsTimeout": "SMS\u78BA\u8A8D\u5FDC\u7B54\u30BF\u30A4\u30E0\u30A2\u30A6\u30C8"
+};
+
+// src/i18n/locales/ar.ts
+var ar = {
+  // Dashboard
+  "relay.title": "ZI2 \u0645\u064F\u0631\u062D\u0651\u0644 \u0627\u0644\u0631\u0633\u0627\u0626\u0644",
+  "relay.connected": "\u0645\u062A\u0635\u0644",
+  "relay.connecting": "\u062C\u0627\u0631\u064D \u0627\u0644\u0627\u062A\u0635\u0627\u0644...",
+  "relay.disconnected": "\u063A\u064A\u0631 \u0645\u062A\u0635\u0644",
+  "relay.uptime": "\u0648\u0642\u062A \u0627\u0644\u062A\u0634\u063A\u064A\u0644",
+  "relay.establishingConnection": "\u062C\u0627\u0631\u064D \u0625\u0646\u0634\u0627\u0621 \u0627\u062A\u0635\u0627\u0644 \u0622\u0645\u0646...",
+  "relay.tapReconnect": "\u0627\u0636\u063A\u0637 \u0639\u0644\u0649 \u0625\u0639\u0627\u062F\u0629 \u0627\u0644\u0627\u062A\u0635\u0627\u0644 \u0644\u0644\u0645\u062D\u0627\u0648\u0644\u0629 \u0645\u0631\u0629 \u0623\u062E\u0631\u0649",
+  "relay.live": "\u0645\u0628\u0627\u0634\u0631",
+  "relay.e2eEncrypted": "\u0645\u0634\u0641\u0631 E2E",
+  "relay.reconnect": "\u0625\u0639\u0627\u062F\u0629 \u0627\u0644\u0627\u062A\u0635\u0627\u0644",
+  "relay.sent": "\u0645\u064F\u0631\u0633\u0644\u0629",
+  "relay.failed": "\u0641\u0627\u0634\u0644\u0629",
+  "relay.remaining": "\u0645\u062A\u0628\u0642\u064A\u0629",
+  "relay.successRate": "\u0645\u0639\u062F\u0644 \u0627\u0644\u0646\u062C\u0627\u062D",
+  "relay.thisSession": "\u0647\u0630\u0647 \u0627\u0644\u062C\u0644\u0633\u0629",
+  "relay.ofPerDay": "\u0645\u0646 {{limit}}/\u064A\u0648\u0645",
+  "relay.total": "\u0627\u0644\u0625\u062C\u0645\u0627\u0644\u064A",
+  "relay.dailyUsage": "\u0627\u0644\u0627\u0633\u062A\u062E\u062F\u0627\u0645 \u0627\u0644\u064A\u0648\u0645\u064A",
+  "relay.perMin": "{{limit}}/\u062F\u0642\u064A\u0642\u0629",
+  "relay.perHr": "{{limit}}/\u0633\u0627\u0639\u0629",
+  "relay.perDay": "{{limit}}/\u064A\u0648\u0645",
+  "relay.quickControls": "\u0623\u062F\u0648\u0627\u062A \u0627\u0644\u062A\u062D\u0643\u0645 \u0627\u0644\u0633\u0631\u064A\u0639",
+  "relay.forceReconnect": "\u0625\u062C\u0628\u0627\u0631 \u0625\u0639\u0627\u062F\u0629 \u0627\u0644\u0627\u062A\u0635\u0627\u0644",
+  "relay.forceReconnectDesc": "\u0625\u0639\u0627\u062F\u0629 \u0625\u0646\u0634\u0627\u0621 \u0627\u062A\u0635\u0627\u0644 WebSocket",
+  "relay.pauseRelay": "\u0625\u064A\u0642\u0627\u0641 \u0627\u0644\u0645\u064F\u0631\u062D\u0651\u0644 \u0645\u0624\u0642\u062A\u0627\u064B",
+  "relay.pauseRelayDesc": "\u0625\u064A\u0642\u0627\u0641 \u0627\u0633\u062A\u0642\u0628\u0627\u0644 \u0627\u0644\u0631\u0633\u0627\u0626\u0644 \u0645\u0624\u0642\u062A\u0627\u064B",
+  "relay.resumeRelay": "\u0627\u0633\u062A\u0626\u0646\u0627\u0641 \u0627\u0644\u0645\u064F\u0631\u062D\u0651\u0644",
+  "relay.resumeRelayDesc": "\u0627\u0633\u062A\u0626\u0646\u0627\u0641 \u0627\u0633\u062A\u0642\u0628\u0627\u0644 \u0627\u0644\u0631\u0633\u0627\u0626\u0644",
+  "relay.sendDeviceStatus": "\u0625\u0631\u0633\u0627\u0644 \u062D\u0627\u0644\u0629 \u0627\u0644\u062C\u0647\u0627\u0632",
+  "relay.sendDeviceStatusDesc": "\u0625\u0628\u0644\u0627\u063A \u0627\u0644\u0628\u0637\u0627\u0631\u064A\u0629 \u0648\u0627\u0644\u0625\u0634\u0627\u0631\u0629 \u0644\u0644\u062E\u0627\u062F\u0645",
+  "relay.messageLog": "\u0633\u062C\u0644 \u0627\u0644\u0631\u0633\u0627\u0626\u0644",
+  "relay.messagesRecorded": "{{count}} \u0631\u0633\u0627\u0644\u0629 \u0645\u0633\u062C\u0644\u0629",
+  "relay.connectionInfo": "\u0645\u0639\u0644\u0648\u0645\u0627\u062A \u0627\u0644\u0627\u062A\u0635\u0627\u0644",
+  "relay.notPaired": "\u063A\u064A\u0631 \u0645\u0642\u062A\u0631\u0646",
+  "relay.noServer": "\u0644\u0627 \u064A\u0648\u062C\u062F \u062E\u0627\u062F\u0645",
+  "relay.recentActivity": "\u0627\u0644\u0646\u0634\u0627\u0637 \u0627\u0644\u0623\u062E\u064A\u0631",
+  "relay.viewAll": "\u0639\u0631\u0636 \u0627\u0644\u0643\u0644",
+  "relay.noMessagesYet": "\u0644\u0627 \u062A\u0648\u062C\u062F \u0631\u0633\u0627\u0626\u0644 \u0628\u0639\u062F",
+  "relay.smsWillAppear": "\u0633\u062A\u0638\u0647\u0631 \u0627\u0644\u0631\u0633\u0627\u0626\u0644 \u0647\u0646\u0627 \u0639\u0646\u062F \u062A\u0631\u062D\u064A\u0644\u0647\u0627",
+  "relay.delivered": "\u062A\u0645 \u0627\u0644\u062A\u0633\u0644\u064A\u0645",
+  "relay.smsPermissionRequired": "\u0625\u0630\u0646 \u0627\u0644\u0631\u0633\u0627\u0626\u0644 \u0645\u0637\u0644\u0648\u0628",
+  "relay.smsPermissionDesc": "\u0627\u0645\u0646\u062D \u0625\u0630\u0646 \u0627\u0644\u0631\u0633\u0627\u0626\u0644 \u0641\u064A \u0625\u0639\u062F\u0627\u062F\u0627\u062A \u0627\u0644\u062C\u0647\u0627\u0632 \u0644\u0625\u0631\u0633\u0627\u0644 \u0627\u0644\u0631\u0633\u0627\u0626\u0644",
+  "relay.retry": "\u0625\u0639\u0627\u062F\u0629 \u0627\u0644\u0645\u062D\u0627\u0648\u0644\u0629",
+  // Pairing
+  "relay.pairingTitle": "ZI2 \u0645\u064F\u0631\u062D\u0651\u0644 \u0627\u0644\u0631\u0633\u0627\u0626\u0644",
+  "relay.pairingInstruction": "\u0648\u062C\u0651\u0647 \u0627\u0644\u0643\u0627\u0645\u064A\u0631\u0627 \u0625\u0644\u0649 \u0631\u0645\u0632 QR \u0639\u0644\u0649 \u0634\u0627\u0634\u062A\u0643 \u0644\u0644\u0627\u0642\u062A\u0631\u0627\u0646.",
+  "relay.pairingWithServer": "\u062C\u0627\u0631\u064D \u0627\u0644\u0627\u0642\u062A\u0631\u0627\u0646 \u0628\u0627\u0644\u062E\u0627\u062F\u0645...",
+  "relay.pairingFailed": "\u0641\u0634\u0644 \u0627\u0644\u0627\u0642\u062A\u0631\u0627\u0646",
+  "relay.tryAgain": "\u062D\u0627\u0648\u0644 \u0645\u0631\u0629 \u0623\u062E\u0631\u0649",
+  "relay.cameraAccessDenied": "\u062A\u0645 \u0631\u0641\u0636 \u0627\u0644\u0648\u0635\u0648\u0644 \u0625\u0644\u0649 \u0627\u0644\u0643\u0627\u0645\u064A\u0631\u0627",
+  // Settings
+  "relay.settings": "\u0627\u0644\u0625\u0639\u062F\u0627\u062F\u0627\u062A",
+  "relay.relayInformation": "\u0645\u0639\u0644\u0648\u0645\u0627\u062A \u0627\u0644\u0645\u064F\u0631\u062D\u0651\u0644",
+  "relay.relayId": "\u0645\u0639\u0631\u0651\u0641 \u0627\u0644\u0645\u064F\u0631\u062D\u0651\u0644",
+  "relay.server": "\u0627\u0644\u062E\u0627\u062F\u0645",
+  "relay.status": "\u0627\u0644\u062D\u0627\u0644\u0629",
+  "relay.online": "\u0645\u062A\u0635\u0644",
+  "relay.offline": "\u063A\u064A\u0631 \u0645\u062A\u0635\u0644",
+  "relay.encryption": "\u0627\u0644\u062A\u0634\u0641\u064A\u0631",
+  "relay.sessionStatistics": "\u0625\u062D\u0635\u0627\u0626\u064A\u0627\u062A \u0627\u0644\u062C\u0644\u0633\u0629",
+  "relay.messagesSent": "\u0627\u0644\u0631\u0633\u0627\u0626\u0644 \u0627\u0644\u0645\u0631\u0633\u0644\u0629",
+  "relay.messagesFailed": "\u0627\u0644\u0631\u0633\u0627\u0626\u0644 \u0627\u0644\u0641\u0627\u0634\u0644\u0629",
+  "relay.totalLogged": "\u0625\u062C\u0645\u0627\u0644\u064A \u0627\u0644\u0645\u0633\u062C\u0644",
+  "relay.rateLimits": "\u062D\u062F\u0648\u062F \u0627\u0644\u0645\u0639\u062F\u0644",
+  "relay.perMinute": "\u0641\u064A \u0627\u0644\u062F\u0642\u064A\u0642\u0629",
+  "relay.perHour": "\u0641\u064A \u0627\u0644\u0633\u0627\u0639\u0629",
+  "relay.perDayLabel": "\u0641\u064A \u0627\u0644\u064A\u0648\u0645",
+  "relay.messageExpiry": "\u0627\u0646\u062A\u0647\u0627\u0621 \u0635\u0644\u0627\u062D\u064A\u0629 \u0627\u0644\u0631\u0633\u0627\u0626\u0644",
+  "relay.expiryHours": "{{hours}} \u0633\u0627\u0639\u0629",
+  "relay.about": "\u062D\u0648\u0644",
+  "relay.version": "ZI2 \u0645\u064F\u0631\u062D\u0651\u0644 \u0627\u0644\u0631\u0633\u0627\u0626\u0644 v1.0.0",
+  "relay.aboutDescription": "\u064A\u0631\u062D\u0651\u0644 \u0631\u0633\u0627\u0626\u0644 SMS \u0645\u0646 \u062E\u0627\u062F\u0645 ZI2 \u0639\u0628\u0631 \u0628\u0637\u0627\u0642\u0629 SIM \u0627\u0644\u0623\u0635\u0644\u064A\u0629 \u0644\u0647\u0627\u062A\u0641\u0643. \u062C\u0645\u064A\u0639 \u0627\u0644\u0631\u0633\u0627\u0626\u0644 \u0645\u0634\u0641\u0631\u0629 \u0645\u0646 \u0637\u0631\u0641 \u0625\u0644\u0649 \u0637\u0631\u0641 \u0628\u0627\u0633\u062A\u062E\u062F\u0627\u0645 \u062A\u0628\u0627\u062F\u0644 \u0645\u0641\u0627\u062A\u064A\u062D X25519 \u0648 AES-256-GCM.",
+  "relay.dangerZone": "\u0645\u0646\u0637\u0642\u0629 \u0627\u0644\u062E\u0637\u0631",
+  "relay.dangerZoneDesc": "\u0645\u0633\u062D \u062C\u0645\u064A\u0639 \u0627\u0644\u0628\u064A\u0627\u0646\u0627\u062A \u0648\u0625\u0644\u063A\u0627\u0621 \u0627\u0642\u062A\u0631\u0627\u0646 \u0647\u0630\u0627 \u0627\u0644\u062C\u0647\u0627\u0632 \u0645\u0646 \u0627\u0644\u062E\u0627\u062F\u0645. \u0633\u064A\u062A\u0637\u0644\u0628 \u0630\u0644\u0643 \u0625\u0639\u0627\u062F\u0629 \u0627\u0644\u0627\u0642\u062A\u0631\u0627\u0646 \u0639\u0628\u0631 \u0631\u0645\u0632 QR.",
+  "relay.clearDataUnpair": "\u0645\u0633\u062D \u0627\u0644\u0628\u064A\u0627\u0646\u0627\u062A \u0648\u0625\u0644\u063A\u0627\u0621 \u0627\u0644\u0627\u0642\u062A\u0631\u0627\u0646",
+  "relay.confirmClearData": "\u062A\u0623\u0643\u064A\u062F - \u0645\u0633\u062D \u062C\u0645\u064A\u0639 \u0627\u0644\u0628\u064A\u0627\u0646\u0627\u062A \u0648\u0625\u0644\u063A\u0627\u0621 \u0627\u0644\u0627\u0642\u062A\u0631\u0627\u0646",
+  // Message Log
+  "relay.messageLogTitle": "\u0633\u062C\u0644 \u0627\u0644\u0631\u0633\u0627\u0626\u0644",
+  "relay.totalLabel": "\u0625\u062C\u0645\u0627\u0644\u064A",
+  "relay.all": "\u0627\u0644\u0643\u0644",
+  "relay.noFilteredMessages": "\u0644\u0627 \u062A\u0648\u062C\u062F \u0631\u0633\u0627\u0626\u0644 {{filter}}",
+  "relay.messagesWillAppear": "\u0633\u062A\u0638\u0647\u0631 \u0627\u0644\u0631\u0633\u0627\u0626\u0644 \u0647\u0646\u0627 \u0639\u0646\u062F \u062A\u0631\u062D\u064A\u0644 \u0627\u0644\u0631\u0633\u0627\u0626\u0644",
+  "relay.sentLabel": "\u0645\u064F\u0631\u0633\u0644",
+  "relay.failLabel": "\u0641\u0627\u0634\u0644",
+  "relay.e2eFooter": "\u0645\u062D\u062A\u0648\u0649 \u0627\u0644\u0631\u0633\u0627\u0644\u0629 \u0645\u0634\u0641\u0631 E2E \u0648\u0644\u0627 \u064A\u062A\u0645 \u062A\u062E\u0632\u064A\u0646\u0647 \u0639\u0644\u0649 \u0627\u0644\u062C\u0647\u0627\u0632",
+  "relay.copied": "\u062A\u0645 \u0627\u0644\u0646\u0633\u062E!",
+  "relay.na": "\u063A/\u0645",
+  "relay.cancel": "\u0625\u0644\u063A\u0627\u0621",
+  // Error codes
+  "errors.relayNotFound": "\u0644\u0645 \u064A\u062A\u0645 \u0627\u0644\u0639\u062B\u0648\u0631 \u0639\u0644\u0649 \u062C\u0647\u0627\u0632 \u0627\u0644\u0645\u064F\u0631\u062D\u0651\u0644",
+  "errors.relayInactive": "\u0627\u0644\u0645\u064F\u0631\u062D\u0651\u0644 \u063A\u064A\u0631 \u0646\u0634\u0637",
+  "errors.relayOffline": "\u062C\u0647\u0627\u0632 \u0627\u0644\u0645\u064F\u0631\u062D\u0651\u0644 \u063A\u064A\u0631 \u0645\u062A\u0635\u0644",
+  "errors.pairingNotFound": "\u0644\u0645 \u064A\u062A\u0645 \u0627\u0644\u0639\u062B\u0648\u0631 \u0639\u0644\u0649 \u062C\u0644\u0633\u0629 \u0627\u0644\u0627\u0642\u062A\u0631\u0627\u0646",
+  "errors.pairingExpired": "\u0627\u0646\u062A\u0647\u062A \u0635\u0644\u0627\u062D\u064A\u0629 \u062C\u0644\u0633\u0629 \u0627\u0644\u0627\u0642\u062A\u0631\u0627\u0646",
+  "errors.pairingInvalidToken": "\u0631\u0645\u0632 \u0627\u0642\u062A\u0631\u0627\u0646 \u063A\u064A\u0631 \u0635\u0627\u0644\u062D",
+  "errors.authTimeout": "\u0627\u0646\u062A\u0647\u062A \u0645\u0647\u0644\u0629 \u0645\u0635\u0627\u062F\u0642\u0629 WebSocket",
+  "errors.authFailed": "\u0628\u064A\u0627\u0646\u0627\u062A \u0627\u0639\u062A\u0645\u0627\u062F \u0627\u0644\u0645\u064F\u0631\u062D\u0651\u0644 \u063A\u064A\u0631 \u0635\u0627\u0644\u062D\u0629",
+  "errors.rateLimited": "\u062A\u0645 \u062A\u062C\u0627\u0648\u0632 \u062D\u062F \u0627\u0644\u0645\u0639\u062F\u0644",
+  "errors.encryptionFailed": "\u0641\u0634\u0644\u062A \u0639\u0645\u0644\u064A\u0629 \u0627\u0644\u062A\u0634\u0641\u064A\u0631",
+  "errors.rekeyFailed": "\u0641\u0634\u0644 \u062A\u062F\u0648\u064A\u0631 \u0627\u0644\u0645\u0641\u062A\u0627\u062D",
+  "errors.smsSendFailed": "\u0641\u0634\u0644 \u062A\u0633\u0644\u064A\u0645 \u0627\u0644\u0631\u0633\u0627\u0644\u0629",
+  "errors.smsTimeout": "\u0627\u0646\u062A\u0647\u062A \u0645\u0647\u0644\u0629 \u062A\u0623\u0643\u064A\u062F \u0627\u0633\u062A\u0644\u0627\u0645 \u0627\u0644\u0631\u0633\u0627\u0644\u0629"
+};
+
+// src/i18n/locales/zh.ts
+var zh = {
+  // Dashboard
+  "relay.title": "ZI2 \u77ED\u4FE1\u4E2D\u7EE7",
+  "relay.connected": "\u5DF2\u8FDE\u63A5",
+  "relay.connecting": "\u8FDE\u63A5\u4E2D...",
+  "relay.disconnected": "\u5DF2\u65AD\u5F00",
+  "relay.uptime": "\u8FD0\u884C\u65F6\u95F4",
+  "relay.establishingConnection": "\u6B63\u5728\u5EFA\u7ACB\u5B89\u5168\u8FDE\u63A5...",
+  "relay.tapReconnect": "\u70B9\u51FB\u91CD\u65B0\u8FDE\u63A5\u4EE5\u91CD\u8BD5",
+  "relay.live": "\u5728\u7EBF",
+  "relay.e2eEncrypted": "\u7AEF\u5230\u7AEF\u52A0\u5BC6",
+  "relay.reconnect": "\u91CD\u65B0\u8FDE\u63A5",
+  "relay.sent": "\u5DF2\u53D1\u9001",
+  "relay.failed": "\u5931\u8D25",
+  "relay.remaining": "\u5269\u4F59",
+  "relay.successRate": "\u6210\u529F\u7387",
+  "relay.thisSession": "\u672C\u6B21\u4F1A\u8BDD",
+  "relay.ofPerDay": "{{limit}}/\u5929 \u4E2D\u7684",
+  "relay.total": "\u603B\u8BA1",
+  "relay.dailyUsage": "\u6BCF\u65E5\u7528\u91CF",
+  "relay.perMin": "{{limit}}/\u5206\u949F",
+  "relay.perHr": "{{limit}}/\u5C0F\u65F6",
+  "relay.perDay": "{{limit}}/\u5929",
+  "relay.quickControls": "\u5FEB\u6377\u63A7\u5236",
+  "relay.forceReconnect": "\u5F3A\u5236\u91CD\u8FDE",
+  "relay.forceReconnectDesc": "\u91CD\u65B0\u5EFA\u7ACBWebSocket\u8FDE\u63A5",
+  "relay.pauseRelay": "\u6682\u505C\u4E2D\u7EE7",
+  "relay.pauseRelayDesc": "\u6682\u65F6\u505C\u6B62\u63A5\u6536\u77ED\u4FE1",
+  "relay.resumeRelay": "\u6062\u590D\u4E2D\u7EE7",
+  "relay.resumeRelayDesc": "\u91CD\u65B0\u5F00\u59CB\u63A5\u6536\u77ED\u4FE1",
+  "relay.sendDeviceStatus": "\u53D1\u9001\u8BBE\u5907\u72B6\u6001",
+  "relay.sendDeviceStatusDesc": "\u5411\u670D\u52A1\u5668\u62A5\u544A\u7535\u6C60\u548C\u4FE1\u53F7\u72B6\u6001",
+  "relay.messageLog": "\u6D88\u606F\u65E5\u5FD7",
+  "relay.messagesRecorded": "\u5DF2\u8BB0\u5F55 {{count}} \u6761\u6D88\u606F",
+  "relay.connectionInfo": "\u8FDE\u63A5\u4FE1\u606F",
+  "relay.notPaired": "\u672A\u914D\u5BF9",
+  "relay.noServer": "\u65E0\u670D\u52A1\u5668",
+  "relay.recentActivity": "\u6700\u8FD1\u6D3B\u52A8",
+  "relay.viewAll": "\u67E5\u770B\u5168\u90E8",
+  "relay.noMessagesYet": "\u6682\u65E0\u6D88\u606F",
+  "relay.smsWillAppear": "\u77ED\u4FE1\u4E2D\u7EE7\u540E\u5C06\u5728\u6B64\u663E\u793A",
+  "relay.delivered": "\u5DF2\u9001\u8FBE",
+  "relay.smsPermissionRequired": "\u9700\u8981\u77ED\u4FE1\u6743\u9650",
+  "relay.smsPermissionDesc": "\u8BF7\u5728\u8BBE\u5907\u8BBE\u7F6E\u4E2D\u6388\u4E88\u77ED\u4FE1\u6743\u9650\u4EE5\u53D1\u9001\u6D88\u606F",
+  "relay.retry": "\u91CD\u8BD5",
+  // Pairing
+  "relay.pairingTitle": "ZI2 \u77ED\u4FE1\u4E2D\u7EE7",
+  "relay.pairingInstruction": "\u5C06\u6444\u50CF\u5934\u5BF9\u51C6\u5C4F\u5E55\u4E0A\u7684\u4E8C\u7EF4\u7801\u4EE5\u914D\u5BF9\u3002",
+  "relay.pairingWithServer": "\u6B63\u5728\u4E0E\u670D\u52A1\u5668\u914D\u5BF9...",
+  "relay.pairingFailed": "\u914D\u5BF9\u5931\u8D25",
+  "relay.tryAgain": "\u91CD\u8BD5",
+  "relay.cameraAccessDenied": "\u6444\u50CF\u5934\u8BBF\u95EE\u88AB\u62D2\u7EDD",
+  // Settings
+  "relay.settings": "\u8BBE\u7F6E",
+  "relay.relayInformation": "\u4E2D\u7EE7\u4FE1\u606F",
+  "relay.relayId": "\u4E2D\u7EE7ID",
+  "relay.server": "\u670D\u52A1\u5668",
+  "relay.status": "\u72B6\u6001",
+  "relay.online": "\u5728\u7EBF",
+  "relay.offline": "\u79BB\u7EBF",
+  "relay.encryption": "\u52A0\u5BC6",
+  "relay.sessionStatistics": "\u4F1A\u8BDD\u7EDF\u8BA1",
+  "relay.messagesSent": "\u5DF2\u53D1\u9001\u6D88\u606F",
+  "relay.messagesFailed": "\u5931\u8D25\u6D88\u606F",
+  "relay.totalLogged": "\u603B\u8BB0\u5F55\u6570",
+  "relay.rateLimits": "\u901F\u7387\u9650\u5236",
+  "relay.perMinute": "\u6BCF\u5206\u949F",
+  "relay.perHour": "\u6BCF\u5C0F\u65F6",
+  "relay.perDayLabel": "\u6BCF\u5929",
+  "relay.messageExpiry": "\u6D88\u606F\u8FC7\u671F",
+  "relay.expiryHours": "{{hours}}\u5C0F\u65F6",
+  "relay.about": "\u5173\u4E8E",
+  "relay.version": "ZI2 \u77ED\u4FE1\u4E2D\u7EE7 v1.0.0",
+  "relay.aboutDescription": "\u901A\u8FC7\u624B\u673A\u539F\u751FSIM\u5361\u4E2D\u7EE7ZI2\u670D\u52A1\u5668\u7684\u77ED\u4FE1\u3002\u6240\u6709\u6D88\u606F\u5747\u4F7F\u7528X25519\u5BC6\u94A5\u4EA4\u6362\u548CAES-256-GCM\u8FDB\u884C\u7AEF\u5230\u7AEF\u52A0\u5BC6\u3002\u670D\u52A1\u5668\u6C38\u8FDC\u4E0D\u4F1A\u770B\u5230\u660E\u6587\u6D88\u606F\u5185\u5BB9\u3002",
+  "relay.dangerZone": "\u5371\u9669\u533A\u57DF",
+  "relay.dangerZoneDesc": "\u6E05\u9664\u6240\u6709\u6570\u636E\u5E76\u53D6\u6D88\u6B64\u8BBE\u5907\u4E0E\u670D\u52A1\u5668\u7684\u914D\u5BF9\u3002\u8FD9\u5C06\u9700\u8981\u901A\u8FC7\u4E8C\u7EF4\u7801\u91CD\u65B0\u914D\u5BF9\u3002",
+  "relay.clearDataUnpair": "\u6E05\u9664\u6570\u636E\u5E76\u53D6\u6D88\u914D\u5BF9",
+  "relay.confirmClearData": "\u786E\u8BA4 - \u6E05\u9664\u6240\u6709\u6570\u636E\u5E76\u53D6\u6D88\u914D\u5BF9",
+  // Message Log
+  "relay.messageLogTitle": "\u6D88\u606F\u65E5\u5FD7",
+  "relay.totalLabel": "\u603B\u8BA1",
+  "relay.all": "\u5168\u90E8",
+  "relay.noFilteredMessages": "\u6CA1\u6709{{filter}}\u6D88\u606F",
+  "relay.messagesWillAppear": "\u77ED\u4FE1\u4E2D\u7EE7\u540E\u6D88\u606F\u5C06\u5728\u6B64\u663E\u793A",
+  "relay.sentLabel": "\u5DF2\u53D1\u9001",
+  "relay.failLabel": "\u5931\u8D25",
+  "relay.e2eFooter": "\u6D88\u606F\u5185\u5BB9\u5DF2\u7AEF\u5230\u7AEF\u52A0\u5BC6\uFF0C\u4E0D\u4F1A\u5B58\u50A8\u5728\u8BBE\u5907\u4E0A",
+  "relay.copied": "\u5DF2\u590D\u5236\uFF01",
+  "relay.na": "N/A",
+  "relay.cancel": "\u53D6\u6D88",
+  // Error codes
+  "errors.relayNotFound": "\u672A\u627E\u5230\u4E2D\u7EE7\u8BBE\u5907",
+  "errors.relayInactive": "\u4E2D\u7EE7\u672A\u6FC0\u6D3B",
+  "errors.relayOffline": "\u4E2D\u7EE7\u8BBE\u5907\u79BB\u7EBF",
+  "errors.pairingNotFound": "\u672A\u627E\u5230\u914D\u5BF9\u4F1A\u8BDD",
+  "errors.pairingExpired": "\u914D\u5BF9\u4F1A\u8BDD\u5DF2\u8FC7\u671F",
+  "errors.pairingInvalidToken": "\u65E0\u6548\u7684\u914D\u5BF9\u4EE4\u724C",
+  "errors.authTimeout": "WebSocket\u8BA4\u8BC1\u8D85\u65F6",
+  "errors.authFailed": "\u65E0\u6548\u7684\u4E2D\u7EE7\u51ED\u636E",
+  "errors.rateLimited": "\u8D85\u51FA\u901F\u7387\u9650\u5236",
+  "errors.encryptionFailed": "\u52A0\u5BC6\u64CD\u4F5C\u5931\u8D25",
+  "errors.rekeyFailed": "\u5BC6\u94A5\u8F6E\u6362\u5931\u8D25",
+  "errors.smsSendFailed": "\u77ED\u4FE1\u53D1\u9001\u5931\u8D25",
+  "errors.smsTimeout": "\u77ED\u4FE1\u786E\u8BA4\u8D85\u65F6"
+};
+
+// src/i18n/locales/pt.ts
+var pt = {
+  // Dashboard
+  "relay.title": "ZI2 Relay SMS",
+  "relay.connected": "Conectado",
+  "relay.connecting": "Conectando...",
+  "relay.disconnected": "Desconectado",
+  "relay.uptime": "Tempo ativo",
+  "relay.establishingConnection": "Estabelecendo conex\xE3o segura...",
+  "relay.tapReconnect": "Toque em reconectar para tentar novamente",
+  "relay.live": "AO VIVO",
+  "relay.e2eEncrypted": "Criptografia E2E",
+  "relay.reconnect": "Reconectar",
+  "relay.sent": "Enviadas",
+  "relay.failed": "Falharam",
+  "relay.remaining": "Restantes",
+  "relay.successRate": "Taxa de sucesso",
+  "relay.thisSession": "esta sess\xE3o",
+  "relay.ofPerDay": "de {{limit}}/dia",
+  "relay.total": "Total",
+  "relay.dailyUsage": "Uso di\xE1rio",
+  "relay.perMin": "{{limit}}/min",
+  "relay.perHr": "{{limit}}/h",
+  "relay.perDay": "{{limit}}/dia",
+  "relay.quickControls": "Controles r\xE1pidos",
+  "relay.forceReconnect": "For\xE7ar reconex\xE3o",
+  "relay.forceReconnectDesc": "Restabelecer conex\xE3o WebSocket",
+  "relay.pauseRelay": "Pausar relay",
+  "relay.pauseRelayDesc": "Parar temporariamente de receber SMS",
+  "relay.resumeRelay": "Retomar relay",
+  "relay.resumeRelayDesc": "Voltar a receber SMS",
+  "relay.sendDeviceStatus": "Enviar status do dispositivo",
+  "relay.sendDeviceStatusDesc": "Reportar bateria e sinal ao servidor",
+  "relay.messageLog": "Registro de mensagens",
+  "relay.messagesRecorded": "{{count}} mensagens registradas",
+  "relay.connectionInfo": "Informa\xE7\xF5es de conex\xE3o",
+  "relay.notPaired": "N\xE3o pareado",
+  "relay.noServer": "Sem servidor",
+  "relay.recentActivity": "Atividade recente",
+  "relay.viewAll": "Ver tudo",
+  "relay.noMessagesYet": "Nenhuma mensagem ainda",
+  "relay.smsWillAppear": "SMS aparecer\xE3o aqui quando forem retransmitidos",
+  "relay.delivered": "Entregue",
+  "relay.smsPermissionRequired": "Permiss\xE3o de SMS necess\xE1ria",
+  "relay.smsPermissionDesc": "Conceda permiss\xE3o de SMS nas configura\xE7\xF5es do dispositivo para enviar mensagens",
+  "relay.retry": "Tentar novamente",
+  // Pairing
+  "relay.pairingTitle": "ZI2 Relay SMS",
+  "relay.pairingInstruction": "Aponte a c\xE2mera para o c\xF3digo QR na sua tela para parear.",
+  "relay.pairingWithServer": "Pareando com o servidor...",
+  "relay.pairingFailed": "Falha no pareamento",
+  "relay.tryAgain": "Tentar novamente",
+  "relay.cameraAccessDenied": "Acesso \xE0 c\xE2mera negado",
+  // Settings
+  "relay.settings": "Configura\xE7\xF5es",
+  "relay.relayInformation": "Informa\xE7\xF5es do relay",
+  "relay.relayId": "ID do relay",
+  "relay.server": "Servidor",
+  "relay.status": "Status",
+  "relay.online": "Online",
+  "relay.offline": "Offline",
+  "relay.encryption": "Criptografia",
+  "relay.sessionStatistics": "Estat\xEDsticas da sess\xE3o",
+  "relay.messagesSent": "Mensagens enviadas",
+  "relay.messagesFailed": "Mensagens com falha",
+  "relay.totalLogged": "Total registrado",
+  "relay.rateLimits": "Limites de taxa",
+  "relay.perMinute": "Por minuto",
+  "relay.perHour": "Por hora",
+  "relay.perDayLabel": "Por dia",
+  "relay.messageExpiry": "Expira\xE7\xE3o de mensagens",
+  "relay.expiryHours": "{{hours}}h",
+  "relay.about": "Sobre",
+  "relay.version": "ZI2 Relay SMS v1.0.0",
+  "relay.aboutDescription": "Retransmite mensagens SMS do seu servidor ZI2 atrav\xE9s do cart\xE3o SIM nativo do seu telefone. Todas as mensagens s\xE3o criptografadas de ponta a ponta usando troca de chaves X25519 e AES-256-GCM.",
+  "relay.dangerZone": "Zona de perigo",
+  "relay.dangerZoneDesc": "Limpar todos os dados e desparear este dispositivo do servidor. Isso exigir\xE1 um novo pareamento via c\xF3digo QR.",
+  "relay.clearDataUnpair": "Limpar dados e desparear",
+  "relay.confirmClearData": "Confirmar - Limpar todos os dados e desparear",
+  // Message Log
+  "relay.messageLogTitle": "Registro de mensagens",
+  "relay.totalLabel": "total",
+  "relay.all": "Todos",
+  "relay.noFilteredMessages": "Nenhuma mensagem {{filter}}",
+  "relay.messagesWillAppear": "Mensagens aparecer\xE3o aqui quando SMS forem retransmitidos",
+  "relay.sentLabel": "ENVIADO",
+  "relay.failLabel": "FALHA",
+  "relay.e2eFooter": "O conte\xFAdo da mensagem \xE9 criptografado E2E e n\xE3o \xE9 armazenado no dispositivo",
+  "relay.copied": "Copiado!",
+  "relay.na": "N/A",
+  "relay.cancel": "Cancelar",
+  // Error codes
+  "errors.relayNotFound": "Dispositivo relay n\xE3o encontrado",
+  "errors.relayInactive": "O relay n\xE3o est\xE1 ativo",
+  "errors.relayOffline": "Dispositivo relay est\xE1 offline",
+  "errors.pairingNotFound": "Sess\xE3o de pareamento n\xE3o encontrada",
+  "errors.pairingExpired": "A sess\xE3o de pareamento expirou",
+  "errors.pairingInvalidToken": "Token de pareamento inv\xE1lido",
+  "errors.authTimeout": "Tempo limite de autentica\xE7\xE3o WebSocket",
+  "errors.authFailed": "Credenciais do relay inv\xE1lidas",
+  "errors.rateLimited": "Limite de taxa excedido",
+  "errors.encryptionFailed": "Opera\xE7\xE3o de criptografia falhou",
+  "errors.rekeyFailed": "Rota\xE7\xE3o de chaves falhou",
+  "errors.smsSendFailed": "Entrega de SMS falhou",
+  "errors.smsTimeout": "Tempo limite de confirma\xE7\xE3o de SMS"
+};
+
+// src/i18n/locales/ko.ts
+var ko = {
+  // Dashboard
+  "relay.title": "ZI2 SMS \uB9B4\uB808\uC774",
+  "relay.connected": "\uC5F0\uACB0\uB428",
+  "relay.connecting": "\uC5F0\uACB0 \uC911...",
+  "relay.disconnected": "\uC5F0\uACB0 \uB04A\uAE40",
+  "relay.uptime": "\uAC00\uB3D9 \uC2DC\uAC04",
+  "relay.establishingConnection": "\uBCF4\uC548 \uC5F0\uACB0 \uC124\uC815 \uC911...",
+  "relay.tapReconnect": "\uC7AC\uC5F0\uACB0\uC744 \uD0ED\uD558\uC5EC \uC7AC\uC2DC\uB3C4",
+  "relay.live": "\uB77C\uC774\uBE0C",
+  "relay.e2eEncrypted": "E2E \uC554\uD638\uD654",
+  "relay.reconnect": "\uC7AC\uC5F0\uACB0",
+  "relay.sent": "\uBC1C\uC1A1\uB428",
+  "relay.failed": "\uC2E4\uD328",
+  "relay.remaining": "\uB0A8\uC740 \uC218",
+  "relay.successRate": "\uC131\uACF5\uB960",
+  "relay.thisSession": "\uC774\uBC88 \uC138\uC158",
+  "relay.ofPerDay": "{{limit}}/\uC77C \uC911",
+  "relay.total": "\uD569\uACC4",
+  "relay.dailyUsage": "\uC77C\uC77C \uC0AC\uC6A9\uB7C9",
+  "relay.perMin": "{{limit}}/\uBD84",
+  "relay.perHr": "{{limit}}/\uC2DC\uAC04",
+  "relay.perDay": "{{limit}}/\uC77C",
+  "relay.quickControls": "\uBE60\uB978 \uC81C\uC5B4",
+  "relay.forceReconnect": "\uAC15\uC81C \uC7AC\uC5F0\uACB0",
+  "relay.forceReconnectDesc": "WebSocket \uC5F0\uACB0 \uC7AC\uC124\uC815",
+  "relay.pauseRelay": "\uB9B4\uB808\uC774 \uC77C\uC2DC \uC911\uC9C0",
+  "relay.pauseRelayDesc": "\uC77C\uC2DC\uC801\uC73C\uB85C SMS \uC218\uC2E0 \uC911\uC9C0",
+  "relay.resumeRelay": "\uB9B4\uB808\uC774 \uC7AC\uAC1C",
+  "relay.resumeRelayDesc": "SMS \uC218\uC2E0 \uC7AC\uAC1C",
+  "relay.sendDeviceStatus": "\uAE30\uAE30 \uC0C1\uD0DC \uC804\uC1A1",
+  "relay.sendDeviceStatusDesc": "\uBC30\uD130\uB9AC \uBC0F \uC2E0\uD638\uB97C \uC11C\uBC84\uC5D0 \uBCF4\uACE0",
+  "relay.messageLog": "\uBA54\uC2DC\uC9C0 \uB85C\uADF8",
+  "relay.messagesRecorded": "{{count}}\uAC1C\uC758 \uBA54\uC2DC\uC9C0 \uAE30\uB85D\uB428",
+  "relay.connectionInfo": "\uC5F0\uACB0 \uC815\uBCF4",
+  "relay.notPaired": "\uD398\uC5B4\uB9C1 \uC548 \uB428",
+  "relay.noServer": "\uC11C\uBC84 \uC5C6\uC74C",
+  "relay.recentActivity": "\uCD5C\uADFC \uD65C\uB3D9",
+  "relay.viewAll": "\uBAA8\uB450 \uBCF4\uAE30",
+  "relay.noMessagesYet": "\uC544\uC9C1 \uBA54\uC2DC\uC9C0 \uC5C6\uC74C",
+  "relay.smsWillAppear": "\uB9B4\uB808\uC774\uB41C SMS\uAC00 \uC5EC\uAE30\uC5D0 \uD45C\uC2DC\uB429\uB2C8\uB2E4",
+  "relay.delivered": "\uC804\uB2EC\uB428",
+  "relay.smsPermissionRequired": "SMS \uAD8C\uD55C \uD544\uC694",
+  "relay.smsPermissionDesc": "\uBA54\uC2DC\uC9C0\uB97C \uBCF4\uB0B4\uB824\uBA74 \uAE30\uAE30 \uC124\uC815\uC5D0\uC11C SMS \uAD8C\uD55C\uC744 \uD5C8\uC6A9\uD558\uC138\uC694",
+  "relay.retry": "\uC7AC\uC2DC\uB3C4",
+  // Pairing
+  "relay.pairingTitle": "ZI2 SMS \uB9B4\uB808\uC774",
+  "relay.pairingInstruction": "\uD654\uBA74\uC758 QR \uCF54\uB4DC\uC5D0 \uCE74\uBA54\uB77C\uB97C \uAC00\uB9AC\uCF1C \uD398\uC5B4\uB9C1\uD558\uC138\uC694.",
+  "relay.pairingWithServer": "\uC11C\uBC84\uC640 \uD398\uC5B4\uB9C1 \uC911...",
+  "relay.pairingFailed": "\uD398\uC5B4\uB9C1 \uC2E4\uD328",
+  "relay.tryAgain": "\uB2E4\uC2DC \uC2DC\uB3C4",
+  "relay.cameraAccessDenied": "\uCE74\uBA54\uB77C \uC561\uC138\uC2A4 \uAC70\uBD80\uB428",
+  // Settings
+  "relay.settings": "\uC124\uC815",
+  "relay.relayInformation": "\uB9B4\uB808\uC774 \uC815\uBCF4",
+  "relay.relayId": "\uB9B4\uB808\uC774 ID",
+  "relay.server": "\uC11C\uBC84",
+  "relay.status": "\uC0C1\uD0DC",
+  "relay.online": "\uC628\uB77C\uC778",
+  "relay.offline": "\uC624\uD504\uB77C\uC778",
+  "relay.encryption": "\uC554\uD638\uD654",
+  "relay.sessionStatistics": "\uC138\uC158 \uD1B5\uACC4",
+  "relay.messagesSent": "\uBC1C\uC1A1\uB41C \uBA54\uC2DC\uC9C0",
+  "relay.messagesFailed": "\uC2E4\uD328\uD55C \uBA54\uC2DC\uC9C0",
+  "relay.totalLogged": "\uCD1D \uAE30\uB85D",
+  "relay.rateLimits": "\uC18D\uB3C4 \uC81C\uD55C",
+  "relay.perMinute": "\uBD84\uB2F9",
+  "relay.perHour": "\uC2DC\uAC04\uB2F9",
+  "relay.perDayLabel": "\uC77C\uB2F9",
+  "relay.messageExpiry": "\uBA54\uC2DC\uC9C0 \uB9CC\uB8CC",
+  "relay.expiryHours": "{{hours}}\uC2DC\uAC04",
+  "relay.about": "\uC815\uBCF4",
+  "relay.version": "ZI2 SMS \uB9B4\uB808\uC774 v1.0.0",
+  "relay.aboutDescription": "ZI2 \uC11C\uBC84\uC758 SMS \uBA54\uC2DC\uC9C0\uB97C \uD734\uB300\uD3F0\uC758 \uAE30\uBCF8 SIM \uCE74\uB4DC\uB97C \uD1B5\uD574 \uB9B4\uB808\uC774\uD569\uB2C8\uB2E4. \uBAA8\uB4E0 \uBA54\uC2DC\uC9C0\uB294 X25519 \uD0A4 \uAD50\uD658 \uBC0F AES-256-GCM\uC73C\uB85C \uC885\uB2E8 \uAC04 \uC554\uD638\uD654\uB429\uB2C8\uB2E4.",
+  "relay.dangerZone": "\uC704\uD5D8 \uAD6C\uC5ED",
+  "relay.dangerZoneDesc": "\uBAA8\uB4E0 \uB370\uC774\uD130\uB97C \uC9C0\uC6B0\uACE0 \uC774 \uAE30\uAE30\uC758 \uC11C\uBC84 \uD398\uC5B4\uB9C1\uC744 \uD574\uC81C\uD569\uB2C8\uB2E4. QR \uCF54\uB4DC\uB85C \uB2E4\uC2DC \uD398\uC5B4\uB9C1\uD574\uC57C \uD569\uB2C8\uB2E4.",
+  "relay.clearDataUnpair": "\uB370\uC774\uD130 \uC0AD\uC81C \uBC0F \uD398\uC5B4\uB9C1 \uD574\uC81C",
+  "relay.confirmClearData": "\uD655\uC778 - \uBAA8\uB4E0 \uB370\uC774\uD130 \uC0AD\uC81C \uBC0F \uD398\uC5B4\uB9C1 \uD574\uC81C",
+  // Message Log
+  "relay.messageLogTitle": "\uBA54\uC2DC\uC9C0 \uB85C\uADF8",
+  "relay.totalLabel": "\uD569\uACC4",
+  "relay.all": "\uC804\uCCB4",
+  "relay.noFilteredMessages": "{{filter}} \uBA54\uC2DC\uC9C0 \uC5C6\uC74C",
+  "relay.messagesWillAppear": "SMS\uAC00 \uB9B4\uB808\uC774\uB418\uBA74 \uC5EC\uAE30\uC5D0 \uBA54\uC2DC\uC9C0\uAC00 \uD45C\uC2DC\uB429\uB2C8\uB2E4",
+  "relay.sentLabel": "\uBC1C\uC1A1",
+  "relay.failLabel": "\uC2E4\uD328",
+  "relay.e2eFooter": "\uBA54\uC2DC\uC9C0 \uB0B4\uC6A9\uC740 E2E \uC554\uD638\uD654\uB418\uC5B4 \uAE30\uAE30\uC5D0 \uC800\uC7A5\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4",
+  "relay.copied": "\uBCF5\uC0AC\uB428!",
+  "relay.na": "N/A",
+  "relay.cancel": "\uCDE8\uC18C",
+  // Error codes
+  "errors.relayNotFound": "\uB9B4\uB808\uC774 \uAE30\uAE30\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+  "errors.relayInactive": "\uB9B4\uB808\uC774\uAC00 \uD65C\uC131 \uC0C1\uD0DC\uAC00 \uC544\uB2D9\uB2C8\uB2E4",
+  "errors.relayOffline": "\uB9B4\uB808\uC774 \uAE30\uAE30\uAC00 \uC624\uD504\uB77C\uC778\uC785\uB2C8\uB2E4",
+  "errors.pairingNotFound": "\uD398\uC5B4\uB9C1 \uC138\uC158\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+  "errors.pairingExpired": "\uD398\uC5B4\uB9C1 \uC138\uC158\uC774 \uB9CC\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4",
+  "errors.pairingInvalidToken": "\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uD398\uC5B4\uB9C1 \uD1A0\uD070",
+  "errors.authTimeout": "WebSocket \uC778\uC99D \uC2DC\uAC04 \uCD08\uACFC",
+  "errors.authFailed": "\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uB9B4\uB808\uC774 \uC790\uACA9 \uC99D\uBA85",
+  "errors.rateLimited": "\uC18D\uB3C4 \uC81C\uD55C \uCD08\uACFC",
+  "errors.encryptionFailed": "\uC554\uD638\uD654 \uC791\uC5C5 \uC2E4\uD328",
+  "errors.rekeyFailed": "\uD0A4 \uB85C\uD14C\uC774\uC158 \uC2E4\uD328",
+  "errors.smsSendFailed": "SMS \uC804\uB2EC \uC2E4\uD328",
+  "errors.smsTimeout": "SMS \uD655\uC778 \uC2DC\uAC04 \uCD08\uACFC"
+};
+
+// src/i18n/locales/it.ts
+var it = {
+  // Dashboard
+  "relay.title": "ZI2 Relay SMS",
+  "relay.connected": "Connesso",
+  "relay.connecting": "Connessione...",
+  "relay.disconnected": "Disconnesso",
+  "relay.uptime": "Tempo attivo",
+  "relay.establishingConnection": "Stabilendo connessione sicura...",
+  "relay.tapReconnect": "Tocca riconnetti per riprovare",
+  "relay.live": "LIVE",
+  "relay.e2eEncrypted": "Crittografia E2E",
+  "relay.reconnect": "Riconnetti",
+  "relay.sent": "Inviati",
+  "relay.failed": "Falliti",
+  "relay.remaining": "Rimanenti",
+  "relay.successRate": "Tasso di successo",
+  "relay.thisSession": "questa sessione",
+  "relay.ofPerDay": "di {{limit}}/giorno",
+  "relay.total": "Totale",
+  "relay.dailyUsage": "Utilizzo giornaliero",
+  "relay.perMin": "{{limit}}/min",
+  "relay.perHr": "{{limit}}/ora",
+  "relay.perDay": "{{limit}}/giorno",
+  "relay.quickControls": "Controlli rapidi",
+  "relay.forceReconnect": "Forza riconnessione",
+  "relay.forceReconnectDesc": "Ristabilisci la connessione WebSocket",
+  "relay.pauseRelay": "Metti in pausa il relay",
+  "relay.pauseRelayDesc": "Interrompi temporaneamente la ricezione di SMS",
+  "relay.resumeRelay": "Riprendi relay",
+  "relay.resumeRelayDesc": "Riprendi la ricezione di SMS",
+  "relay.sendDeviceStatus": "Invia stato dispositivo",
+  "relay.sendDeviceStatusDesc": "Segnala batteria e segnale al server",
+  "relay.messageLog": "Registro messaggi",
+  "relay.messagesRecorded": "{{count}} messaggi registrati",
+  "relay.connectionInfo": "Informazioni connessione",
+  "relay.notPaired": "Non associato",
+  "relay.noServer": "Nessun server",
+  "relay.recentActivity": "Attivit\xE0 recente",
+  "relay.viewAll": "Vedi tutto",
+  "relay.noMessagesYet": "Nessun messaggio ancora",
+  "relay.smsWillAppear": "Gli SMS appariranno qui quando vengono inoltrati",
+  "relay.delivered": "Consegnato",
+  "relay.smsPermissionRequired": "Permesso SMS richiesto",
+  "relay.smsPermissionDesc": "Concedi il permesso SMS nelle impostazioni del dispositivo per inviare messaggi",
+  "relay.retry": "Riprova",
+  // Pairing
+  "relay.pairingTitle": "ZI2 Relay SMS",
+  "relay.pairingInstruction": "Punta la fotocamera verso il codice QR sullo schermo per associare.",
+  "relay.pairingWithServer": "Associazione con il server...",
+  "relay.pairingFailed": "Associazione fallita",
+  "relay.tryAgain": "Riprova",
+  "relay.cameraAccessDenied": "Accesso alla fotocamera negato",
+  // Settings
+  "relay.settings": "Impostazioni",
+  "relay.relayInformation": "Informazioni relay",
+  "relay.relayId": "ID relay",
+  "relay.server": "Server",
+  "relay.status": "Stato",
+  "relay.online": "Online",
+  "relay.offline": "Offline",
+  "relay.encryption": "Crittografia",
+  "relay.sessionStatistics": "Statistiche sessione",
+  "relay.messagesSent": "Messaggi inviati",
+  "relay.messagesFailed": "Messaggi falliti",
+  "relay.totalLogged": "Totale registrato",
+  "relay.rateLimits": "Limiti di frequenza",
+  "relay.perMinute": "Al minuto",
+  "relay.perHour": "All'ora",
+  "relay.perDayLabel": "Al giorno",
+  "relay.messageExpiry": "Scadenza messaggi",
+  "relay.expiryHours": "{{hours}}h",
+  "relay.about": "Informazioni",
+  "relay.version": "ZI2 Relay SMS v1.0.0",
+  "relay.aboutDescription": "Inoltra i messaggi SMS dal tuo server ZI2 attraverso la scheda SIM nativa del tuo telefono. Tutti i messaggi sono crittografati end-to-end con scambio chiavi X25519 e AES-256-GCM.",
+  "relay.dangerZone": "Zona pericolosa",
+  "relay.dangerZoneDesc": "Cancella tutti i dati e dissocia questo dispositivo dal server. Sar\xE0 necessaria una nuova associazione tramite codice QR.",
+  "relay.clearDataUnpair": "Cancella dati e dissocia",
+  "relay.confirmClearData": "Conferma - Cancella tutti i dati e dissocia",
+  // Message Log
+  "relay.messageLogTitle": "Registro messaggi",
+  "relay.totalLabel": "totale",
+  "relay.all": "Tutti",
+  "relay.noFilteredMessages": "Nessun messaggio {{filter}}",
+  "relay.messagesWillAppear": "I messaggi appariranno qui quando gli SMS vengono inoltrati",
+  "relay.sentLabel": "INVIATO",
+  "relay.failLabel": "FALLITO",
+  "relay.e2eFooter": "Il contenuto del messaggio \xE8 crittografato E2E e non viene memorizzato sul dispositivo",
+  "relay.copied": "Copiato!",
+  "relay.na": "N/D",
+  "relay.cancel": "Annulla",
+  // Error codes
+  "errors.relayNotFound": "Dispositivo relay non trovato",
+  "errors.relayInactive": "Il relay non \xE8 attivo",
+  "errors.relayOffline": "Il dispositivo relay \xE8 offline",
+  "errors.pairingNotFound": "Sessione di associazione non trovata",
+  "errors.pairingExpired": "La sessione di associazione \xE8 scaduta",
+  "errors.pairingInvalidToken": "Token di associazione non valido",
+  "errors.authTimeout": "Timeout autenticazione WebSocket",
+  "errors.authFailed": "Credenziali relay non valide",
+  "errors.rateLimited": "Limite di frequenza superato",
+  "errors.encryptionFailed": "Operazione di crittografia fallita",
+  "errors.rekeyFailed": "Rotazione chiavi fallita",
+  "errors.smsSendFailed": "Consegna SMS fallita",
+  "errors.smsTimeout": "Timeout conferma ricezione SMS"
+};
+
+// src/i18n/index.ts
+var locales = { en, fr, es, de, ja, ar, zh, pt, ko, it };
+function getTranslation(locale, key) {
+  const dict = locales[locale] || locales.en;
+  return dict[key] || locales.en[key] || key;
+}
+function getSupportedLocales() {
+  return Object.keys(locales);
+}
+function getRelayTranslations(locale) {
+  return locales[locale] || locales.en;
+}
+
+// src/index.ts
+function createRelay(config) {
+  const logger = config.logger || new ConsoleLogger();
+  const broadcast = config.broadcast || new NoopBroadcast();
+  const audit = config.audit || new NoopAudit();
+  const authLimiter = new AuthLimiter(config.maxAuthFailuresPerIp ?? 10);
+  const enforceTls = config.enforceTls ?? true;
+  const limits = { ...RELAY_LIMITS, ...config.limits };
+  const events = new RelayEventEmitter();
+  const queue = createQueueService({
+    db: config.db,
+    encryption: config.encryption,
+    logger,
+    events,
+    limits
+  });
+  const pairing = createPairingService({
+    db: config.db,
+    encryption: config.encryption,
+    logger,
+    apiUrl: config.apiUrl || "http://localhost:3000",
+    wsUrl: config.wsUrl || "",
+    limits,
+    onPairingComplete: config.onPairingComplete,
+    onRelayRevoked: config.onRelayRevoked
+  });
+  const health = createHealthService({
+    db: config.db,
+    logger,
+    limits
+  });
+  const handleWs = createWebSocketHandler({
+    db: config.db,
+    encryption: config.encryption,
+    broadcast,
+    logger,
+    events,
+    queue,
+    limits
+  });
+  const sdk = {
+    // Pairing
+    async initiatePairing(orgId, userId) {
+      return pairing.initiatePairing(orgId, userId);
+    },
+    async completePairing(input) {
+      return pairing.completePairing(
+        input.pairingId,
+        input.pairingToken,
+        input.devicePublicKey,
+        input.deviceName,
+        input.platform,
+        input.phoneNumber
+      );
+    },
+    // Relay management
+    async listRelays(orgId) {
+      const relays = await config.db.findRelays(orgId, "revoked");
+      const todayUTC = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      return relays.map(({ dailyResetAt, ...relay }) => ({
+        ...relay,
+        dailySmsSent: dailyResetAt && dailyResetAt.toISOString().slice(0, 10) === todayUTC ? relay.dailySmsSent : 0,
+        isOnline: isRelayOnline(relay.id)
+      }));
+    },
+    async getRelay(id, orgId) {
+      const relay = await config.db.findRelay(id, orgId);
+      if (!relay) return null;
+      const todayUTC = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const isToday = relay.dailyResetAt && relay.dailyResetAt.toISOString().slice(0, 10) === todayUTC;
+      return {
+        ...relay,
+        dailySmsSent: isToday ? relay.dailySmsSent : 0,
+        isOnline: isRelayOnline(relay.id)
+      };
+    },
+    async updateRelay(id, orgId, data) {
+      await config.db.updateRelayByOrg(id, orgId, data);
+    },
+    async revokeRelay(id, orgId) {
+      return pairing.revokeRelay(id, orgId);
+    },
+    async rotateKeys(id, orgId) {
+      return pairing.rotateKeys(id, orgId);
+    },
+    // Messaging
+    async sendSMS(options) {
+      return queue.enqueueAndWait(options);
+    },
+    async getMessages(relayId, orgId, limit = 50, offset = 0) {
+      const relay = await config.db.findRelay(relayId, orgId);
+      if (!relay) throw new Error("Relay not found");
+      const { messages, total } = await config.db.findMessages(relayId, limit, offset);
+      return { messages, pagination: { total, limit, offset } };
+    },
+    // Connection status
+    isRelayOnline(relayId) {
+      return isRelayOnline(relayId);
+    },
+    getRelaySocket(relayId) {
+      return getRelaySocket(relayId);
+    },
+    // WebSocket handler
+    handleWebSocket(socket, request) {
+      handleWs(socket, request);
+    },
+    // Health
+    async runHealthCheck() {
+      return health.runHealthCheck();
+    },
+    startHealthService() {
+      health.startHealthService();
+    },
+    stopHealthService() {
+      health.stopHealthService();
+    },
+    // Provider factory
+    createProvider(relayId, orgId) {
+      const provider = new PhoneRelayProvider(queue);
+      provider.initialize({ relayId, orgId });
+      return provider;
+    },
+    createFallbackProvider(fallbackConfig) {
+      return new FallbackProvider(fallbackConfig);
+    },
+    // Event subscriptions
+    onRelayOnline(callback) {
+      return events.on("relay:online", callback);
+    },
+    onRelayOffline(callback) {
+      return events.on("relay:offline", callback);
+    },
+    onMessageDelivered(callback) {
+      return events.on("message:delivered", callback);
+    },
+    onMessageFailed(callback) {
+      return events.on("message:failed", callback);
+    }
+  };
+  return sdk;
+}
+export {
+  AesGcmEncryption,
+  AuthLimiter,
+  ConsoleAudit,
+  ConsoleLogger,
+  FallbackProvider,
+  MemoryAdapter,
+  NoopAudit,
+  NoopBroadcast,
+  PhoneRelayProvider,
+  RELAY_DELIVERY_STATUS,
+  RELAY_ERRORS,
+  RELAY_ERRORS_EXTENDED,
+  RELAY_LIMITS,
+  RELAY_MESSAGE_STATUS,
+  RELAY_MESSAGE_TYPES,
+  RELAY_PAIRING_STATUS,
+  RELAY_PLATFORMS,
+  RELAY_STATUS,
+  RedisBroker,
+  RelayError,
+  completePairingSchema,
+  createRelay,
+  createRelayError,
+  decryptE2E,
+  deriveSharedKey,
+  encryptE2E,
+  generateSecureToken,
+  generateX25519KeyPair,
+  getRelaySocket,
+  getRelayTranslations,
+  getSupportedLocales,
+  getTranslation,
+  hashToken,
+  isRelayOnline,
+  relayMessagesQuerySchema,
+  testRelaySmsSchema,
+  timingSafeCompare,
+  updatePhoneRelaySchema,
+  withRedaction
+};