@neetru/sdk 3.6.0 → 3.7.0

package/dist/mocks.mjs

@@ -1,5 +1,5 @@
 // src/errors.ts
-var NeetruError = class _NeetruError extends Error {
+var l = class m extends Error {
   code;
   status;
   requestId;
@@ -12,24 +12,17 @@ var NeetruError = class _NeetruError extends Error {
    * para um `NeetruDbErrorCode` mais específico (recuperável vs não).
    */
   reason;
-  constructor(code, message, status, requestId, reason) {
-    super(message);
-    this.name = "NeetruError";
-    this.code = code;
-    this.status = status;
-    this.requestId = requestId;
-    this.reason = reason;
-    Object.setPrototypeOf(this, _NeetruError.prototype);
+  constructor(e, r, i, o, a) {
+    super(r), this.name = "NeetruError", this.code = e, this.status = i, this.requestId = o, this.reason = a, Object.setPrototypeOf(this, m.prototype);
   }
 };
 
 // src/db-errors.ts
-var RETRYABLE_CODES = /* @__PURE__ */ new Set([
+var U = /* @__PURE__ */ new Set([
   "db_unavailable",
   "db_conflict",
   "db_timeout"
-]);
-var NeetruDbError = class _NeetruDbError extends NeetruError {
+]), _ = class m extends l {
   /** Código de erro fechado — específico de DB. */
   code;
   /**
@@ -42,79 +35,60 @@ var NeetruDbError = class _NeetruDbError extends NeetruError {
    * Nunca deve ser exibido ao usuário final.
    */
   dbId;
-  constructor(code, message, dbId) {
-    super(code, message);
-    this.name = "NeetruDbError";
-    this.code = code;
-    this.retryable = RETRYABLE_CODES.has(code);
-    this.dbId = dbId;
-    Object.setPrototypeOf(this, _NeetruDbError.prototype);
+  constructor(e, r, i) {
+    super(e, r), this.name = "NeetruDbError", this.code = e, this.retryable = U.has(e), this.dbId = i, Object.setPrototypeOf(this, m.prototype);
   }
 };
 
 // src/runtime-env.ts
-function isProductionRuntime() {
+function R() {
   try {
-    if (typeof process !== "undefined" && process.env) {
+    if (typeof process < "u" && process.env)
       return process.env.NODE_ENV === "production";
-    }
   } catch {
   }
   return false;
 }
 
 // src/mocks.ts
-var DEV_FIXTURE_USER = Object.freeze({
+var x = Object.freeze({
   uid: "dev-fixture-uid-0001",
   email: "dev@neetru.local",
   emailVerified: true,
   displayName: "Dev Fixture",
   isCustomer: true,
   isStaff: false
-});
-var MockAuth = class {
+}), A = class {
   _user;
   _listeners;
   _allowUnsignedDecode;
-  constructor(initialUser = null, options) {
-    this._user = initialUser;
-    this._listeners = /* @__PURE__ */ new Set();
-    this._allowUnsignedDecode = options?.allowUnsignedDecode ?? false;
-    if (this._allowUnsignedDecode && isProductionRuntime()) {
-      throw new NeetruError(
+  constructor(e = null, r) {
+    if (this._user = e, this._listeners = /* @__PURE__ */ new Set(), this._allowUnsignedDecode = r?.allowUnsignedDecode ?? false, this._allowUnsignedDecode && R())
+      throw new l(
         "invalid_config",
         "MockAuth com allowUnsignedDecode=true \xE9 PROIBIDO em produ\xE7\xE3o (NODE_ENV=production): decodificar JWT sem verificar assinatura \xE9 bypass de autentica\xE7\xE3o. Este modo existe exclusivamente para testes."
       );
-    }
-    if (this._allowUnsignedDecode) {
-      const isTestEnv = typeof process !== "undefined" && (process.env?.NODE_ENV === "test" || process.env?.VITEST === "true" || process.env?.VITEST != null);
-      if (!isTestEnv && typeof console !== "undefined") {
-        console.warn(
-          "[neetru-sdk] MockAuth.verifyToken est\xE1 em modo allowUnsignedDecode=true: tokens N\xC3O t\xEAm assinatura verificada. Este modo \xE9 exclusivo para testes \u2014 NUNCA use como security boundary em c\xF3digo deployado."
-        );
-      }
-    }
+    this._allowUnsignedDecode && !(typeof process < "u" && (process.env?.NODE_ENV === "test" || process.env?.VITEST === "true" || process.env?.VITEST != null)) && typeof console < "u" && console.warn(
+      "[neetru-sdk] MockAuth.verifyToken est\xE1 em modo allowUnsignedDecode=true: tokens N\xC3O t\xEAm assinatura verificada. Este modo \xE9 exclusivo para testes \u2014 NUNCA use como security boundary em c\xF3digo deployado."
+    );
   }
-  async signIn(_options) {
-    if (!this._user) this._user = { ...DEV_FIXTURE_USER };
-    this._notify();
-    return this._user;
+  async signIn(e) {
+    return this._user || (this._user = { ...x }), this._notify(), this._user;
   }
   async signOut() {
-    this._user = null;
-    this._notify();
+    this._user = null, this._notify();
   }
   getUser() {
     return this._user;
   }
-  onAuthStateChanged(listener) {
-    this._listeners.add(listener);
+  onAuthStateChanged(e) {
+    this._listeners.add(e);
     try {
-      listener(this._user);
+      e(this._user);
     } catch {
     }
     return () => {
-      this._listeners.delete(listener);
+      this._listeners.delete(e);
     };
   }
   /**
@@ -127,52 +101,46 @@ var MockAuth = class {
    *
    * Para simular falhas ou resultados customizados, use `__mockVerifyToken(fn)`.
    */
-  async verifyToken(token) {
-    if (this._verifyTokenOverride) {
-      return this._verifyTokenOverride(token);
-    }
-    if (!token) {
-      throw new NeetruError("token_invalid_signature", "Token inv\xE1lido: string vazia");
-    }
-    if (!this._allowUnsignedDecode) {
-      throw new NeetruError(
+  async verifyToken(e) {
+    if (this._verifyTokenOverride)
+      return this._verifyTokenOverride(e);
+    if (!e)
+      throw new l("token_invalid_signature", "Token inv\xE1lido: string vazia");
+    if (!this._allowUnsignedDecode)
+      throw new l(
         "unauthorized",
         "MockAuth.verifyToken n\xE3o verifica assinaturas JWT e N\xC3O deve ser usado como security boundary em c\xF3digo deployado. Em testes, use new MockAuth(user, { allowUnsignedDecode: true }) para habilitar decodifica\xE7\xE3o sem assinatura, ou __mockVerifyToken(fn) para injetar resultado customizado."
       );
-    }
     try {
-      const parts = token.split(".");
-      if (parts.length === 3) {
-        const b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
-        const pad = "=".repeat((4 - b64.length % 4) % 4);
-        const decoded = JSON.parse(
-          typeof atob === "function" ? atob(b64 + pad) : Buffer.from(b64 + pad, "base64").toString("utf-8")
+      let r = e.split(".");
+      if (r.length === 3) {
+        let i = r[1].replace(/-/g, "+").replace(/_/g, "/"), o = "=".repeat((4 - i.length % 4) % 4), a = JSON.parse(
+          typeof atob == "function" ? atob(i + o) : Buffer.from(i + o, "base64").toString("utf-8")
         );
-        if (typeof decoded.sub === "string") {
+        if (typeof a.sub == "string")
           return {
-            uid: decoded.sub,
-            email: typeof decoded.email === "string" ? decoded.email : "",
-            emailVerified: typeof decoded.email_verified === "boolean" ? decoded.email_verified : void 0,
-            displayName: typeof decoded.name === "string" ? decoded.name : void 0,
-            photoURL: typeof decoded.picture === "string" ? decoded.picture : void 0,
-            isStaff: decoded.is_staff === true,
-            isCustomer: decoded.is_customer === true,
-            tenantId: typeof decoded.tenant_id === "string" ? decoded.tenant_id : void 0,
-            ...decoded
+            uid: a.sub,
+            email: typeof a.email == "string" ? a.email : "",
+            emailVerified: typeof a.email_verified == "boolean" ? a.email_verified : void 0,
+            displayName: typeof a.name == "string" ? a.name : void 0,
+            photoURL: typeof a.picture == "string" ? a.picture : void 0,
+            isStaff: a.is_staff === !0,
+            isCustomer: a.is_customer === !0,
+            tenantId: typeof a.tenant_id == "string" ? a.tenant_id : void 0,
+            ...a
           };
-        }
       }
     } catch {
     }
     if (this._user) return this._user;
-    throw new NeetruError("token_invalid_signature", "Nenhum user mock dispon\xEDvel e JWT sem sub v\xE1lido");
+    throw new l("token_invalid_signature", "Nenhum user mock dispon\xEDvel e JWT sem sub v\xE1lido");
   }
   /**
    * Mock de `handleRedirectCallback` (Bug 2 / 3.1.3) — não há redirect real no
    * mock, então retorna `null` por default. Use `__setPendingCallback(result)`
    * em testes pra simular um retorno do IdP.
    */
-  async handleRedirectCallback(_currentUrl) {
+  async handleRedirectCallback(e) {
     return this._pendingCallback;
   }
   /**
@@ -181,7 +149,7 @@ var MockAuth = class {
    * contrato "no-op seguro em todo page load" da implementação real). O login
    * mock acontece direto via `signIn()`.
    */
-  async completeSignIn(_currentUrl) {
+  async completeSignIn(e) {
     return null;
   }
   /**
@@ -194,12 +162,12 @@ var MockAuth = class {
   _pendingCallback = null;
   _idToken = null;
   /** Test helper — simula o material devolvido por um callback OIDC. */
-  __setPendingCallback(result) {
-    this._pendingCallback = result;
+  __setPendingCallback(e) {
+    this._pendingCallback = e;
   }
   /** Test helper — injeta o id_token cru retornado por `getIdToken`. */
-  __setIdToken(token) {
-    this._idToken = token;
+  __setIdToken(e) {
+    this._idToken = e;
   }
   _verifyTokenOverride = null;
   /**
@@ -212,75 +180,63 @@ var MockAuth = class {
    * mock.__mockVerifyToken(async () => { throw new NeetruError('token_expired', '...'); });
    * ```
    */
-  __mockVerifyToken(fn) {
-    this._verifyTokenOverride = fn;
+  __mockVerifyToken(e) {
+    this._verifyTokenOverride = e;
   }
   /** Helper de tests — força um user state arbitrário. */
-  __setUser(user) {
-    this._user = user;
-    this._notify();
+  __setUser(e) {
+    this._user = e, this._notify();
   }
   _notify() {
-    for (const l of this._listeners) {
+    for (let e of this._listeners)
       try {
-        l(this._user);
+        e(this._user);
       } catch {
       }
-    }
   }
-};
-var MockUsage = class {
+}, T = class {
   _reports = [];
   _quotas;
   _counters = /* @__PURE__ */ new Map();
-  constructor(initialQuotas = {}) {
-    this._quotas = new Map(Object.entries(initialQuotas));
-  }
-  async report(resource, qty = 1, options) {
-    if (!resource) throw new Error("resource required");
-    const safeQty = Number.isFinite(qty) && qty > 0 ? Math.floor(qty) : 1;
-    const existing = this._counters.get(resource) ?? 0;
-    const next = existing + safeQty;
-    this._counters.set(resource, next);
-    this._reports.push({
-      resource,
-      qty: safeQty,
-      productId: options?.productId,
-      tenantId: options?.tenantId,
+  constructor(e = {}) {
+    this._quotas = new Map(Object.entries(e));
+  }
+  async report(e, r = 1, i) {
+    if (!e) throw new Error("resource required");
+    let o = Number.isFinite(r) && r > 0 ? Math.floor(r) : 1, c = (this._counters.get(e) ?? 0) + o;
+    this._counters.set(e, c), this._reports.push({
+      resource: e,
+      qty: o,
+      productId: i?.productId,
+      tenantId: i?.tenantId,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
-    const limitFixture = this._quotas.get(resource);
-    const limit = limitFixture?.limit ?? -1;
+    let d = this._quotas.get(e)?.limit ?? -1;
     return {
       ok: true,
-      counterId: `mock_${resource}`,
-      value: next,
-      limit,
-      remaining: limit < 0 ? -1 : Math.max(0, limit - next),
-      status: limit > 0 && next >= limit ? "read_only_overlimit" : "ok"
+      counterId: `mock_${e}`,
+      value: c,
+      limit: d,
+      remaining: d < 0 ? -1 : Math.max(0, d - c),
+      status: d > 0 && c >= d ? "read_only_overlimit" : "ok"
     };
   }
-  async check(resource, _options) {
-    const quota = this._quotas.get(resource);
-    const used = this._counters.get(resource) ?? 0;
-    if (!quota) {
+  async check(e, r) {
+    let i = this._quotas.get(e), o = this._counters.get(e) ?? 0;
+    if (!i)
       return { allowed: true, reason: "granted", limit: -1, remaining: -1, behavior: null };
-    }
-    const remaining = quota.limit < 0 ? -1 : Math.max(0, quota.limit - used);
-    if (remaining === 0) {
-      return {
-        allowed: false,
-        reason: "limit_exceeded",
-        limit: quota.limit,
-        remaining: 0,
-        behavior: "readonly"
-      };
-    }
-    return {
+    let a = i.limit < 0 ? -1 : Math.max(0, i.limit - o);
+    return a === 0 ? {
+      allowed: false,
+      reason: "limit_exceeded",
+      limit: i.limit,
+      remaining: 0,
+      behavior: "readonly"
+    } : {
       allowed: true,
       reason: "granted",
-      limit: quota.limit,
-      remaining,
+      limit: i.limit,
+      remaining: a,
       behavior: null
     };
   }
@@ -293,40 +249,37 @@ var MockUsage = class {
     return this.__getReports();
   }
   /** Test helper — substitui quota fixture. */
-  __setQuota(metric, quota) {
-    this._quotas.set(metric, quota);
+  __setQuota(e, r) {
+    this._quotas.set(e, r);
   }
   /** Test helper — limpa estado. */
   __reset() {
-    this._reports = [];
-    this._quotas.clear();
-    this._counters.clear();
+    this._reports = [], this._quotas.clear(), this._counters.clear();
   }
-};
-var MockSupport = class {
+}, P = class {
   _tickets = [];
   _ticketSeq = 0;
-  async createTicket(input) {
-    if (!input?.subject) throw new NeetruError("validation_failed", "subject required");
-    if (!input?.message) throw new NeetruError("validation_failed", "message required");
-    if (!input?.productSlug) {
-      throw new NeetruError(
+  async createTicket(e) {
+    if (!e?.subject) throw new l("validation_failed", "subject required");
+    if (!e?.message) throw new l("validation_failed", "message required");
+    if (!e?.productSlug)
+      throw new l(
         "validation_failed",
         "productSlug required (3.0 breaking \u2014 pass to input or set on createNeetruClient)"
       );
-    }
-    const ticket = {
+    let r = {
       id: `mock-ticket-${++this._ticketSeq}`,
-      subject: input.subject,
-      message: input.message,
-      severity: input.severity ?? "normal",
+      subject: e.subject,
+      message: e.message,
+      severity: e.severity ?? "normal",
       status: "open",
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      productSlug: input.productSlug,
+      productSlug: e.productSlug,
       // 3.4 (product-feedback): espelha o contrato — campos novos nullable,
       // populados a partir do input quando fornecidos.
-      pageUrl: typeof input.pageUrl === "string" ? input.pageUrl : null,
-      screenshotUrl: typeof input.screenshotBase64 === "string" ? input.screenshotBase64 : null,
+      pageUrl: typeof e.pageUrl == "string" ? e.pageUrl : null,
+      screenshotUrl: typeof e.screenshotBase64 == "string" ? e.screenshotBase64 : null,
+      screenshotAttached: typeof e.screenshotBase64 == "string",
       resolvedAt: null,
       resolvedNotifiedAt: null,
       satisfactionAttempts: 0,
@@ -335,146 +288,116 @@ var MockSupport = class {
       rating: null,
       satisfactionComment: null
     };
-    this._tickets.push(ticket);
-    return ticket;
+    return this._tickets.push(r), r;
   }
-  async listMyTickets(options) {
-    if (options?.productSlug) {
-      return this._tickets.filter((t) => t.productSlug === options.productSlug);
-    }
-    return [...this._tickets];
+  async listMyTickets(e) {
+    return e?.productSlug ? this._tickets.filter((r) => r.productSlug === e.productSlug) : [...this._tickets];
   }
-  _find(ticketId) {
-    if (!ticketId || typeof ticketId !== "string") {
-      throw new NeetruError("validation_failed", "ticketId is required");
-    }
-    const ticket = this._tickets.find((t) => t.id === ticketId);
-    if (!ticket) {
-      throw new NeetruError("not_found", `ticket ${ticketId} not found`);
-    }
-    return ticket;
+  _find(e) {
+    if (!e || typeof e != "string")
+      throw new l("validation_failed", "ticketId is required");
+    let r = this._tickets.find((i) => i.id === e);
+    if (!r)
+      throw new l("not_found", `ticket ${e} not found`);
+    return r;
   }
   /** 3.4: espelha `markResolvedSeen` — idempotente (só seta se ainda null). */
-  async markResolvedSeen(ticketId) {
-    const ticket = this._find(ticketId);
-    if (ticket.resolvedNotifiedAt === null) {
-      ticket.resolvedNotifiedAt = (/* @__PURE__ */ new Date()).toISOString();
-    }
+  async markResolvedSeen(e) {
+    let r = this._find(e);
+    r.resolvedNotifiedAt === null && (r.resolvedNotifiedAt = (/* @__PURE__ */ new Date()).toISOString());
   }
   /** 3.4: espelha `recordSatisfactionAttempt` — incrementa contador. */
-  async recordSatisfactionAttempt(ticketId) {
-    const ticket = this._find(ticketId);
-    ticket.satisfactionAttempts += 1;
-    ticket.lastSatisfactionAttemptAt = (/* @__PURE__ */ new Date()).toISOString();
+  async recordSatisfactionAttempt(e) {
+    let r = this._find(e);
+    r.satisfactionAttempts += 1, r.lastSatisfactionAttemptAt = (/* @__PURE__ */ new Date()).toISOString();
   }
   /** 3.4: espelha `submitSatisfaction` — terminal, seta `satisfiedAt`. */
-  async submitSatisfaction(input) {
-    if (!input || typeof input !== "object") {
-      throw new NeetruError("validation_failed", "input is required");
-    }
-    if (input.rating !== null && input.rating !== void 0) {
-      if (!Number.isInteger(input.rating) || input.rating < 1 || input.rating > 5) {
-        throw new NeetruError("validation_failed", "rating must be an integer 1-5 or null");
-      }
-    }
-    if (typeof input.comment === "string" && input.comment.length > 2e3) {
-      throw new NeetruError("validation_failed", "comment max 2000 chars");
-    }
-    const ticket = this._find(input.ticketId);
-    ticket.satisfiedAt = (/* @__PURE__ */ new Date()).toISOString();
-    ticket.rating = input.rating ?? null;
-    ticket.satisfactionComment = input.comment ?? null;
+  async submitSatisfaction(e) {
+    if (!e || typeof e != "object")
+      throw new l("validation_failed", "input is required");
+    if (e.rating !== null && e.rating !== void 0 && (!Number.isInteger(e.rating) || e.rating < 1 || e.rating > 5))
+      throw new l("validation_failed", "rating must be an integer 1-5 or null");
+    if (typeof e.comment == "string" && e.comment.length > 2e3)
+      throw new l("validation_failed", "comment max 2000 chars");
+    let r = this._find(e.ticketId);
+    r.satisfiedAt = (/* @__PURE__ */ new Date()).toISOString(), r.rating = e.rating ?? null, r.satisfactionComment = e.comment ?? null;
   }
   /** 3.4: espelha `contestTicket` — reabre e zera o ciclo de satisfação. */
-  async contestTicket(ticketId, opts) {
-    if (typeof opts?.comment === "string" && opts.comment.length > 2e3) {
-      throw new NeetruError("validation_failed", "comment max 2000 chars");
-    }
-    const ticket = this._find(ticketId);
-    ticket.status = "open";
-    ticket.resolvedAt = null;
-    ticket.resolvedNotifiedAt = null;
-    ticket.satisfactionAttempts = 0;
-    ticket.lastSatisfactionAttemptAt = null;
-    ticket.satisfiedAt = null;
-    ticket.rating = null;
-    ticket.satisfactionComment = null;
+  async contestTicket(e, r) {
+    if (typeof r?.comment == "string" && r.comment.length > 2e3)
+      throw new l("validation_failed", "comment max 2000 chars");
+    let i = this._find(e);
+    i.status = "open", i.resolvedAt = null, i.resolvedNotifiedAt = null, i.satisfactionAttempts = 0, i.lastSatisfactionAttemptAt = null, i.satisfiedAt = null, i.rating = null, i.satisfactionComment = null;
   }
   /** Test helper. */
   __reset() {
-    this._tickets = [];
-    this._ticketSeq = 0;
+    this._tickets = [], this._ticketSeq = 0;
   }
-};
-var MockEntitlements = class {
+}, D = class {
   _denied = /* @__PURE__ */ new Set();
-  async check(productSlug, feature) {
-    return !this._denied.has(`${productSlug}:${feature}`);
+  async check(e, r) {
+    return !this._denied.has(`${e}:${r}`);
   }
-  async checkDetailed(productSlug, feature) {
-    const allowed = await this.check(productSlug, feature);
+  async checkDetailed(e, r) {
+    let i = await this.check(e, r);
     return {
-      allowed,
-      productSlug,
-      feature,
-      reason: allowed ? "granted" : "mock_denied"
+      allowed: i,
+      productSlug: e,
+      feature: r,
+      reason: i ? "granted" : "mock_denied"
     };
   }
   /** Test helper. */
-  __deny(productSlug, feature) {
-    this._denied.add(`${productSlug}:${feature}`);
+  __deny(e, r) {
+    this._denied.add(`${e}:${r}`);
   }
   /** Test helper. */
   __reset() {
     this._denied.clear();
   }
-};
-var MockDb = class {
+}, C = class {
   _store = /* @__PURE__ */ new Map();
   _fixtures;
-  constructor(initialFixtures = {}) {
-    this._fixtures = new Map(Object.entries(initialFixtures));
-  }
-  collection(name) {
-    const _store = this._store;
-    const _fixtures = this._fixtures;
-    if (!_store.has(name)) {
-      const init = _fixtures.get(name);
-      _store.set(
-        name,
-        init ? new Map(Object.entries(init)) : /* @__PURE__ */ new Map()
+  constructor(e = {}) {
+    this._fixtures = new Map(Object.entries(e));
+  }
+  collection(e) {
+    let r = this._store, i = this._fixtures;
+    if (!r.has(e)) {
+      let s = i.get(e);
+      r.set(
+        e,
+        s ? new Map(Object.entries(s)) : /* @__PURE__ */ new Map()
       );
     }
-    const coll = _store.get(name);
-    const matchesFilter = (doc, f) => {
-      const v = doc[f.field];
-      switch (f.op) {
+    let o = r.get(e), a = (s, t) => {
+      let n = s[t.field];
+      switch (t.op) {
         case "==":
-          return v === f.value;
+          return n === t.value;
         case "!=":
-          return v !== f.value;
+          return n !== t.value;
         case "<":
-          return typeof v === "number" && typeof f.value === "number" && v < f.value;
+          return typeof n == "number" && typeof t.value == "number" && n < t.value;
         case "<=":
-          return typeof v === "number" && typeof f.value === "number" && v <= f.value;
+          return typeof n == "number" && typeof t.value == "number" && n <= t.value;
         case ">":
-          return typeof v === "number" && typeof f.value === "number" && v > f.value;
+          return typeof n == "number" && typeof t.value == "number" && n > t.value;
         case ">=":
-          return typeof v === "number" && typeof f.value === "number" && v >= f.value;
+          return typeof n == "number" && typeof t.value == "number" && n >= t.value;
         case "in":
-          return Array.isArray(f.value) && f.value.includes(v);
+          return Array.isArray(t.value) && t.value.includes(n);
         case "array-contains":
-          return Array.isArray(v) && v.includes(f.value);
+          return Array.isArray(n) && n.includes(t.value);
         case "not-in":
-          return Array.isArray(f.value) && !f.value.includes(v);
+          return Array.isArray(t.value) && !t.value.includes(n);
         default:
           return true;
       }
-    };
-    let autoSeq = 0;
-    function buildListResult(items) {
+    }, c = 0;
+    function y(s) {
       return {
-        docs: items.map((d, i) => ({ id: d.id ?? String(i), data: d })),
+        docs: s.map((t, n) => ({ id: t.id ?? String(n), data: t })),
         nextCursor: null,
         fromCache: false,
         stale: false,
@@ -482,141 +405,111 @@ var MockDb = class {
         changes: []
       };
     }
-    function buildGetResult(data, id) {
+    function d(s, t) {
       return {
-        docs: [{ id, data }],
+        docs: [{ id: t, data: s }],
         fromCache: false,
         stale: false,
         hasPendingWrites: false,
         changes: []
       };
     }
-    const ref = {
-      async list(q) {
-        let items = Array.from(coll.values());
-        if (q?.where && q.where.length > 0) {
-          items = items.filter(
-            (doc) => q.where.every((f) => matchesFilter(doc, f))
-          );
-        }
-        if (q?.orderBy) {
-          const { field, direction } = q.orderBy;
-          items = items.slice().sort((a, b) => {
-            const av = a[field];
-            const bv = b[field];
-            const avs = av ?? "";
-            const bvs = bv ?? "";
-            const cmp = avs < bvs ? -1 : avs > bvs ? 1 : 0;
-            return direction === "desc" ? -cmp : cmp;
+    let f = {
+      async list(s) {
+        let t = Array.from(o.values());
+        if (s?.where && s.where.length > 0 && (t = t.filter(
+          (u) => s.where.every((g) => a(u, g))
+        )), s?.orderBy) {
+          let { field: u, direction: g } = s.orderBy;
+          t = t.slice().sort((p, b) => {
+            let h = p[u], v = b[u], k = h ?? "", w = v ?? "", S = k < w ? -1 : k > w ? 1 : 0;
+            return g === "desc" ? -S : S;
           });
         }
-        const limit = q?.limit ?? 20;
-        items = items.slice(0, limit);
-        return buildListResult(items);
+        let n = s?.limit ?? 20;
+        return t = t.slice(0, n), y(t);
       },
-      async get(id) {
-        const data = coll.get(id);
-        if (!data) return null;
-        return buildGetResult(data, id);
+      async get(s) {
+        let t = o.get(s);
+        return t ? d(t, s) : null;
       },
-      async add(data) {
-        const id = `mock-${++autoSeq}-${Math.random().toString(36).slice(2, 8)}`;
-        coll.set(id, { ...data, id });
-        return { ok: true, id };
+      async add(s) {
+        let t = `mock-${++c}-${Math.random().toString(36).slice(2, 8)}`;
+        return o.set(t, { ...s, id: t }), { ok: true, id: t };
       },
-      async set(id, data) {
-        coll.set(id, { ...data, id });
-        return { ok: true };
+      async set(s, t) {
+        return o.set(s, { ...t, id: s }), { ok: true };
       },
-      async update(id, data) {
-        const cur = coll.get(id);
-        if (!cur) {
-          coll.set(id, { ...data, id });
-        } else {
-          coll.set(id, { ...cur, ...data });
-        }
-        return { ok: true };
+      async update(s, t) {
+        let n = o.get(s);
+        return n ? o.set(s, { ...n, ...t }) : o.set(s, { ...t, id: s }), { ok: true };
       },
-      async remove(id) {
-        coll.delete(id);
-        return { ok: true };
+      async remove(s) {
+        return o.delete(s), { ok: true };
       },
-      async batch(ops) {
-        for (const op of ops) {
-          const collMap = coll;
-          if (op.kind === "add") {
-            const id = `mock-batch-${++autoSeq}`;
-            collMap.set(id, { ...op.data, id });
-          } else if (op.kind === "set") {
-            collMap.set(op.id, { ...op.data, id: op.id });
-          } else if (op.kind === "update") {
-            const cur = collMap.get(op.id);
-            collMap.set(op.id, { ...cur ?? {}, ...op.data, id: op.id });
-          } else if (op.kind === "remove") {
-            collMap.delete(op.id);
-          }
+      async batch(s) {
+        for (let t of s) {
+          let n = o;
+          if (t.kind === "add") {
+            let u = `mock-batch-${++c}`;
+            n.set(u, { ...t.data, id: u });
+          } else if (t.kind === "set")
+            n.set(t.id, { ...t.data, id: t.id });
+          else if (t.kind === "update") {
+            let u = n.get(t.id);
+            n.set(t.id, { ...u ?? {}, ...t.data, id: t.id });
+          } else t.kind === "remove" && n.delete(t.id);
         }
         return { ok: true };
       },
-      onDoc(id, cb) {
-        const data = coll.get(id);
-        Promise.resolve().then(() => cb(data ? data : null));
-        return () => {
+      onDoc(s, t) {
+        let n = o.get(s);
+        return Promise.resolve().then(() => t(n || null)), () => {
         };
       },
-      onSnapshot(q, cb) {
-        Promise.resolve().then(async () => {
-          const snap = await ref.list(q);
-          cb(snap);
-        });
-        return () => {
+      onSnapshot(s, t) {
+        return Promise.resolve().then(async () => {
+          let n = await f.list(s);
+          t(n);
+        }), () => {
         };
       },
-      doc(id) {
+      doc(s) {
         return {
           get id() {
-            return id;
+            return s;
           },
           get path() {
-            return `${name}/${id}`;
+            return `${e}/${s}`;
           },
           get collection() {
-            return name;
+            return e;
           },
           async get() {
-            const data = coll.get(id);
-            if (!data) return null;
-            return buildGetResult(data, id);
+            let t = o.get(s);
+            return t ? d(t, s) : null;
           },
-          async set(data) {
-            coll.set(id, { ...data, id });
-            return { ok: true };
+          async set(t) {
+            return o.set(s, { ...t, id: s }), { ok: true };
           },
-          async update(data) {
-            const cur = coll.get(id);
-            if (!cur) {
-              coll.set(id, { ...data, id });
-            } else {
-              coll.set(id, { ...cur, ...data });
-            }
-            return { ok: true };
+          async update(t) {
+            let n = o.get(s);
+            return n ? o.set(s, { ...n, ...t }) : o.set(s, { ...t, id: s }), { ok: true };
           },
           async remove() {
-            coll.delete(id);
-            return { ok: true };
+            return o.delete(s), { ok: true };
           },
-          onSnapshot(cb) {
-            const data = coll.get(id);
-            Promise.resolve().then(
-              () => cb(data ? buildGetResult(data, id) : null)
-            );
-            return () => {
+          onSnapshot(t) {
+            let n = o.get(s);
+            return Promise.resolve().then(
+              () => t(n ? d(n, s) : null)
+            ), () => {
             };
           }
         };
       }
     };
-    return ref;
+    return f;
   }
   /**
    * Implementa SQL in-memory para testes — preferência: `@electric-sql/pglite`
@@ -637,80 +530,66 @@ var MockDb = class {
    *
    * Use `options.initSql` pra rodar DDL no setup (CREATE TABLE etc).
    */
-  async sql(schema, options) {
-    const ddls = options?.initSql ? Array.isArray(options.initSql) ? options.initSql : [options.initSql] : [];
+  async sql(e, r) {
+    let i = r?.initSql ? Array.isArray(r.initSql) ? r.initSql : [r.initSql] : [];
     try {
-      const pglitePkg = await import(
+      let n = await import(
         /* webpackIgnore: true */
         '@electric-sql/pglite'
-      );
-      const drizzlePglitePkg = await import(
+      ), u = await import(
         /* webpackIgnore: true */
         'drizzle-orm/pglite'
-      );
-      const pglite = await pglitePkg.PGlite.create();
-      for (const ddl of ddls) {
-        await pglite.query(ddl);
-      }
-      const pgliteOrm = drizzlePglitePkg.drizzle(pglite, { schema });
-      const ormAsNode = pgliteOrm;
+      ), g = await n.PGlite.create();
+      for (let h of i)
+        await g.query(h);
+      let p = u.drizzle(g, { schema: e });
       return {
-        orm: ormAsNode,
-        async transaction(fn, _opts) {
-          return await pgliteOrm.transaction(fn);
+        orm: p,
+        async transaction(h, v) {
+          return await p.transaction(h);
         },
         async close() {
-          if (!pglite.closed) await pglite.close();
+          g.closed || await g.close();
         }
       };
-    } catch (_pgliteErr) {
+    } catch {
     }
-    let pgMemMod;
-    let drizzlePg;
+    let o, a;
     try {
-      pgMemMod = await import(
+      o = await import(
         /* webpackIgnore: true */
         'pg-mem'
-      );
-      drizzlePg = await import(
+      ), a = await import(
         /* webpackIgnore: true */
         'drizzle-orm/node-postgres'
       );
     } catch {
-      throw new NeetruDbError(
+      throw new _(
         "db_unavailable",
         "[MockDb] sql() requer @electric-sql/pglite OU pg-mem + drizzle-orm + pg como devDependencies. Preferido: npm install -D @electric-sql/pglite drizzle-orm. Alternativo: npm install -D pg-mem drizzle-orm pg."
       );
     }
-    const memDb = pgMemMod.newDb({ noAstCoverageCheck: true });
-    if (ddls.length > 0) {
-      for (const ddl of ddls) {
-        memDb.public.none(ddl);
-      }
-    }
-    const adapters = memDb.adapters.createPg();
-    const PoolCtor = adapters.Pool;
-    const pool = new PoolCtor();
-    const origQuery = pool.query.bind(pool);
-    pool.query = (q, ...rest) => {
-      if (q !== null && typeof q === "object") {
-        const queryObj = q;
-        const types = queryObj["types"];
-        if (types !== null && typeof types === "object" && "getTypeParser" in types) {
-          delete types["getTypeParser"];
-        }
+    let c = o.newDb({ noAstCoverageCheck: true });
+    if (i.length > 0)
+      for (let n of i)
+        c.public.none(n);
+    let d = c.adapters.createPg().Pool, f = new d(), s = f.query.bind(f);
+    f.query = (n, ...u) => {
+      if (n !== null && typeof n == "object") {
+        let p = n.types;
+        p !== null && typeof p == "object" && "getTypeParser" in p && delete p.getTypeParser;
       }
-      return origQuery(q, ...rest);
+      return s(n, ...u);
     };
-    const orm = drizzlePg.drizzle(pool, { schema });
+    let t = a.drizzle(f, { schema: e });
     return {
-      orm,
-      async transaction(fn, _opts) {
-        return await orm.transaction(fn);
+      orm: t,
+      async transaction(n, u) {
+        return await t.transaction(n);
       },
       async close() {
-        const p = pool;
-        if (p.end) await p.end();
+        let n = f;
+        n.end && await n.end();
       }
     };
   }
@@ -722,7 +601,7 @@ var MockDb = class {
       isLeaderTab: true
     };
   }
-  onSyncStateChanged(_cb) {
+  onSyncStateChanged(e) {
     return () => {
     };
   }
@@ -735,65 +614,53 @@ var MockDb = class {
     return [];
   }
   /** Test helper — substitui fixture inteira de uma collection. */
-  __setFixture(name, items) {
-    this._store.set(name, new Map(Object.entries(items)));
+  __setFixture(e, r) {
+    this._store.set(e, new Map(Object.entries(r)));
   }
   /** Test helper — reset total. */
   __reset() {
     this._store.clear();
   }
-};
-var MockAi = class {
+}, N = class {
   _calls = [];
   /** Extrai texto de um content string OU array multimodal (imagens ignoradas). */
-  _contentToText(content) {
-    if (typeof content === "string") return content;
-    if (!Array.isArray(content)) return "";
-    return content.filter((p) => !!p && p.type === "text").map((p) => p.text).join(" ");
-  }
-  _reply(opts) {
-    const last = [...opts.messages].reverse().find((m) => m.role === "user") ?? opts.messages[opts.messages.length - 1];
-    const content = this._contentToText(last?.content);
-    return content ? `mock-reply: ${content}` : "mock-reply";
-  }
-  async chat(opts) {
-    if (!opts || typeof opts.model !== "string" || opts.model.length === 0) {
-      throw new NeetruError("validation_failed", "ai: model is required");
-    }
-    if (!Array.isArray(opts.messages) || opts.messages.length === 0) {
-      throw new NeetruError("validation_failed", "ai: messages must be a non-empty array");
-    }
-    this._calls.push({ model: opts.model, messages: opts.messages, stream: false });
-    const text = this._reply(opts);
-    const promptTokens = opts.messages.reduce((n, m) => n + this._contentToText(m.content).length, 0);
-    const completionTokens = text.length;
+  _contentToText(e) {
+    return typeof e == "string" ? e : Array.isArray(e) ? e.filter((r) => !!r && r.type === "text").map((r) => r.text).join(" ") : "";
+  }
+  _reply(e) {
+    let r = [...e.messages].reverse().find((o) => o.role === "user") ?? e.messages[e.messages.length - 1], i = this._contentToText(r?.content);
+    return i ? `mock-reply: ${i}` : "mock-reply";
+  }
+  async chat(e) {
+    if (!e || typeof e.model != "string" || e.model.length === 0)
+      throw new l("validation_failed", "ai: model is required");
+    if (!Array.isArray(e.messages) || e.messages.length === 0)
+      throw new l("validation_failed", "ai: messages must be a non-empty array");
+    this._calls.push({ model: e.model, messages: e.messages, stream: false });
+    let r = this._reply(e), i = e.messages.reduce((a, c) => a + this._contentToText(c.content).length, 0), o = r.length;
     return {
-      choices: [{ message: { role: "assistant", content: text }, finish_reason: "stop" }],
+      choices: [{ message: { role: "assistant", content: r }, finish_reason: "stop" }],
       usage: {
-        prompt_tokens: promptTokens,
-        completion_tokens: completionTokens,
-        total_tokens: promptTokens + completionTokens
+        prompt_tokens: i,
+        completion_tokens: o,
+        total_tokens: i + o
       },
-      model: opts.model,
+      model: e.model,
       provider: "mock",
       usageWarning: false
     };
   }
-  stream(opts) {
-    if (!opts || typeof opts.model !== "string" || opts.model.length === 0) {
-      throw new NeetruError("validation_failed", "ai: model is required");
-    }
-    if (!Array.isArray(opts.messages) || opts.messages.length === 0) {
-      throw new NeetruError("validation_failed", "ai: messages must be a non-empty array");
-    }
-    this._calls.push({ model: opts.model, messages: opts.messages, stream: true });
-    const text = this._reply(opts);
-    const parts = text.match(/\S+\s*/g) ?? [text];
-    const meta = Promise.resolve({ provider: "mock", usageWarning: false });
-    async function* iterate() {
-      for (const p of parts) yield p;
+  stream(e) {
+    if (!e || typeof e.model != "string" || e.model.length === 0)
+      throw new l("validation_failed", "ai: model is required");
+    if (!Array.isArray(e.messages) || e.messages.length === 0)
+      throw new l("validation_failed", "ai: messages must be a non-empty array");
+    this._calls.push({ model: e.model, messages: e.messages, stream: true });
+    let r = this._reply(e), i = r.match(/\S+\s*/g) ?? [r], o = Promise.resolve({ provider: "mock", usageWarning: false });
+    async function* a() {
+      for (let c of i) yield c;
     }
-    return { meta, [Symbol.asyncIterator]: iterate };
+    return { meta: o, [Symbol.asyncIterator]: a };
   }
   /** Test helper — histórico de chamadas. */
   __getCalls() {
@@ -801,6 +668,4 @@ var MockAi = class {
   }
 };
 
-export { DEV_FIXTURE_USER, MockAi, MockAuth, MockDb, MockEntitlements, MockSupport, MockUsage };
-//# sourceMappingURL=mocks.mjs.map
-//# sourceMappingURL=mocks.mjs.map
+export { x as DEV_FIXTURE_USER, N as MockAi, A as MockAuth, C as MockDb, D as MockEntitlements, P as MockSupport, T as MockUsage };