@geenius/adapters 0.1.0 → 0.3.0

package/packages/shared/dist/index.js

@@ -0,0 +1,1567 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ADAPTER_DOMAINS: () => ADAPTER_DOMAINS,
+  ADAPTER_STATUSES: () => ADAPTER_STATUSES,
+  ADMIN_PROVIDERS: () => ADMIN_PROVIDERS,
+  AI_PROVIDERS: () => AI_PROVIDERS,
+  AUTH_PROVIDERS: () => AUTH_PROVIDERS,
+  AdapterError: () => AdapterError,
+  AdminError: () => AdminError,
+  AiError: () => AiError,
+  AuthError: () => AuthError,
+  DB_PROVIDERS: () => DB_PROVIDERS,
+  DEFAULT_TIER_GATE: () => DEFAULT_TIER_GATE,
+  DOMAIN_DESCRIPTIONS: () => DOMAIN_DESCRIPTIONS,
+  DOMAIN_ICONS: () => DOMAIN_ICONS,
+  DOMAIN_LABELS: () => DOMAIN_LABELS,
+  DbError: () => DbError,
+  PAYMENT_PROVIDERS: () => PAYMENT_PROVIDERS,
+  PROVIDER_REGISTRY: () => PROVIDER_REGISTRY,
+  PaymentsError: () => PaymentsError,
+  STORAGE_PROVIDERS: () => STORAGE_PROVIDERS,
+  StorageError: () => StorageError,
+  clearResolvers: () => clearResolvers,
+  configureAdapters: () => configureAdapters,
+  createCloudflareKVDbAdapter: () => createCloudflareKVDbAdapter,
+  createConvexDbAdapter: () => createConvexDbAdapter,
+  createLocalStorageAdminAdapter: () => createLocalStorageAdminAdapter,
+  createLocalStorageAiAdapter: () => createLocalStorageAiAdapter,
+  createLocalStorageAuthAdapter: () => createLocalStorageAuthAdapter,
+  createLocalStorageDbAdapter: () => createLocalStorageDbAdapter,
+  createLocalStorageFileAdapter: () => createLocalStorageFileAdapter,
+  createLocalStoragePaymentsAdapter: () => createLocalStoragePaymentsAdapter,
+  createMemoryDbAdapter: () => createMemoryDbAdapter,
+  createMongoDbAdapter: () => createMongoDbAdapter,
+  createNeonDbAdapter: () => createNeonDbAdapter,
+  createNoopPaymentsAdapter: () => createNoopPaymentsAdapter,
+  createSupabaseDbAdapter: () => createSupabaseDbAdapter,
+  getAdapterConfig: () => getAdapterConfig,
+  getAvailableFeatures: () => getAvailableFeatures,
+  getAvailablePackages: () => getAvailablePackages,
+  getDomainConfig: () => getDomainConfig,
+  getProviderMeta: () => getProviderMeta,
+  getProvidersForDomain: () => getProvidersForDomain,
+  getUpgradeFeatures: () => getUpgradeFeatures,
+  hasResolver: () => hasResolver,
+  isAdapterError: () => isAdapterError,
+  isAdaptersConfigured: () => isAdaptersConfigured,
+  isFeatureAvailable: () => isFeatureAvailable,
+  isPackageAvailable: () => isPackageAvailable,
+  isRetryable: () => isRetryable,
+  registerResolver: () => registerResolver,
+  resetAdapterConfig: () => resetAdapterConfig,
+  resolveAdapter: () => resolveAdapter,
+  withRetry: () => withRetry
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var AdapterError = class extends Error {
+  constructor(message, domain, code, cause) {
+    super(message);
+    this.domain = domain;
+    this.code = code;
+    this.cause = cause;
+    this.name = "AdapterError";
+  }
+};
+var DbError = class extends AdapterError {
+  constructor(message, code, cause) {
+    super(message, "db", code, cause);
+    this.name = "DbError";
+  }
+};
+var AuthError = class extends AdapterError {
+  constructor(message, code, cause) {
+    super(message, "auth", code, cause);
+    this.name = "AuthError";
+  }
+};
+var AiError = class extends AdapterError {
+  constructor(message, code, cause) {
+    super(message, "ai", code, cause);
+    this.name = "AiError";
+  }
+};
+var StorageError = class extends AdapterError {
+  constructor(message, code, cause) {
+    super(message, "storage", code, cause);
+    this.name = "StorageError";
+  }
+};
+var PaymentsError = class extends AdapterError {
+  constructor(message, code, cause) {
+    super(message, "payments", code, cause);
+    this.name = "PaymentsError";
+  }
+};
+var AdminError = class extends AdapterError {
+  constructor(message, code, cause) {
+    super(message, "admin", code, cause);
+    this.name = "AdminError";
+  }
+};
+function isAdapterError(error) {
+  return error instanceof AdapterError;
+}
+function isRetryable(error) {
+  if (!isAdapterError(error)) return false;
+  const retryableCodes = /* @__PURE__ */ new Set(["RATE_LIMIT", "CONNECTION_ERROR", "SERVICE_ERROR"]);
+  return retryableCodes.has(error.code);
+}
+
+// src/retry.ts
+async function withRetry(fn, options = {}) {
+  const {
+    maxAttempts = 3,
+    delayMs = 500,
+    backoffMultiplier = 2,
+    shouldRetry = isRetryable
+  } = options;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === maxAttempts || !shouldRetry(error)) {
+        throw error;
+      }
+      const delay = delayMs * Math.pow(backoffMultiplier, attempt - 1);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw lastError;
+}
+
+// src/config.ts
+var _config = null;
+function configureAdapters(config) {
+  _config = config;
+}
+function getAdapterConfig() {
+  if (!_config) {
+    throw new Error("Adapters not configured. Call configureAdapters() first.");
+  }
+  return _config;
+}
+function isAdaptersConfigured() {
+  return _config !== null;
+}
+function resetAdapterConfig() {
+  _config = null;
+}
+function getDomainConfig(domain) {
+  const config = getAdapterConfig();
+  return config[domain] ?? null;
+}
+
+// src/resolve.ts
+var resolvers = /* @__PURE__ */ new Map();
+function registerResolver(domain, provider, resolver) {
+  resolvers.set(`${domain}:${provider}`, resolver);
+}
+function resolveAdapter(domain) {
+  const config = getDomainConfig(domain);
+  if (!config) {
+    throw new Error(`No configuration found for adapter domain: ${domain}`);
+  }
+  const key = `${domain}:${config.provider}`;
+  const resolver = resolvers.get(key);
+  if (!resolver) {
+    throw new Error(
+      `No resolver registered for ${domain}:${config.provider}. Call registerResolver('${domain}', '${config.provider}', factory) first.`
+    );
+  }
+  return resolver(config);
+}
+function hasResolver(domain, provider) {
+  return resolvers.has(`${domain}:${provider}`);
+}
+function clearResolvers() {
+  resolvers.clear();
+}
+
+// src/constants.ts
+var ADAPTER_DOMAINS = [
+  "db",
+  "auth",
+  "payments",
+  "ai",
+  "storage",
+  "admin"
+];
+var DB_PROVIDERS = ["localStorage", "convex", "supabase", "neon", "mongodb"];
+var AUTH_PROVIDERS = ["localStorage", "better-auth", "convex-auth", "clerk", "supabase-auth"];
+var AI_PROVIDERS = ["localStorage", "openai", "anthropic", "gemini", "ollama", "cloudflare-ai-gateway", "vercel-ai-sdk"];
+var STORAGE_PROVIDERS = ["localStorage", "r2", "s3", "uploadthing", "supabase-storage", "convex-storage", "minio"];
+var PAYMENT_PROVIDERS = ["localStorage", "stripe", "noop"];
+var ADMIN_PROVIDERS = ["localStorage"];
+var ADAPTER_STATUSES = ["connected", "disconnected", "error", "initializing"];
+var DOMAIN_LABELS = {
+  db: "Database",
+  auth: "Authentication",
+  payments: "Payments",
+  ai: "AI & LLM",
+  storage: "File Storage",
+  admin: "Admin Panel"
+};
+var DOMAIN_ICONS = {
+  db: "\u{1F5C4}\uFE0F",
+  auth: "\u{1F510}",
+  payments: "\u{1F4B3}",
+  ai: "\u{1F916}",
+  storage: "\u{1F4C1}",
+  admin: "\u2699\uFE0F"
+};
+var DOMAIN_DESCRIPTIONS = {
+  db: "Connect to your preferred database backend for data persistence.",
+  auth: "User authentication, sessions, and identity management.",
+  payments: "Subscriptions, checkout, and billing management.",
+  ai: "AI completions, chat, and embeddings via any LLM provider.",
+  storage: "Upload, download, and manage files with any storage provider.",
+  admin: "Admin dashboard metrics and user management."
+};
+var PROVIDER_REGISTRY = [
+  // DB
+  { id: "localStorage", name: "localStorage", domain: "db", description: "In-browser mock storage for prototyping", tier: "pronto" },
+  { id: "convex", name: "Convex", domain: "db", description: "Real-time cloud database with sub-50ms reactivity", tier: "lancio" },
+  { id: "supabase", name: "Supabase", domain: "db", description: "PostgreSQL + Auth + Storage", tier: "lancio" },
+  { id: "neon", name: "Neon", domain: "db", description: "Serverless PostgreSQL", tier: "lancio" },
+  { id: "mongodb", name: "MongoDB", domain: "db", description: "Document database via Prisma ORM", tier: "lancio" },
+  // Auth
+  { id: "localStorage", name: "localStorage", domain: "auth", description: "Mock auth for prototyping", tier: "pronto" },
+  { id: "better-auth", name: "Better Auth", domain: "auth", description: "Self-hosted auth with OAuth + MFA", tier: "lancio" },
+  { id: "convex-auth", name: "Convex Auth", domain: "auth", description: "Built-in Convex sessions", tier: "lancio" },
+  { id: "clerk", name: "Clerk", domain: "auth", description: "SaaS auth with pre-built UI", tier: "lancio" },
+  { id: "supabase-auth", name: "Supabase Auth", domain: "auth", description: "Built-in Supabase auth", tier: "lancio" },
+  // AI
+  { id: "localStorage", name: "localStorage", domain: "ai", description: "Mock AI for prototyping", tier: "pronto" },
+  { id: "openai", name: "OpenAI", domain: "ai", description: "GPT models with streaming + embeddings", tier: "lancio" },
+  { id: "anthropic", name: "Anthropic", domain: "ai", description: "Claude models with streaming", tier: "lancio" },
+  { id: "gemini", name: "Google Gemini", domain: "ai", description: "Gemini models, zero npm deps", tier: "lancio" },
+  { id: "ollama", name: "Ollama", domain: "ai", description: "Local LLMs, zero npm deps", tier: "lancio" },
+  { id: "cloudflare-ai-gateway", name: "CF AI Gateway", domain: "ai", description: "Caching/rate-limiting proxy", tier: "studio" },
+  { id: "vercel-ai-sdk", name: "Vercel AI SDK", domain: "ai", description: "generateText/embed wrappers", tier: "studio" },
+  // Storage
+  { id: "localStorage", name: "localStorage", domain: "storage", description: "Base64 in-browser storage", tier: "pronto" },
+  { id: "r2", name: "Cloudflare R2", domain: "storage", description: "S3-compatible, zero egress", tier: "lancio" },
+  { id: "s3", name: "AWS S3", domain: "storage", description: "IAM roles + CloudFront CDN", tier: "lancio" },
+  { id: "uploadthing", name: "Uploadthing", domain: "storage", description: "REST API file upload SaaS", tier: "lancio" },
+  { id: "supabase-storage", name: "Supabase Storage", domain: "storage", description: "Native Supabase storage", tier: "lancio" },
+  { id: "convex-storage", name: "Convex Storage", domain: "storage", description: "Convex built-in file storage", tier: "lancio" },
+  { id: "minio", name: "Minio", domain: "storage", description: "Self-hosted S3-compatible", tier: "studio" },
+  // Payments
+  { id: "localStorage", name: "localStorage", domain: "payments", description: "Mock billing for prototyping", tier: "pronto" },
+  { id: "stripe", name: "Stripe", domain: "payments", description: "Full billing, subscriptions, checkout", tier: "lancio" },
+  { id: "noop", name: "Noop", domain: "payments", description: "No-op adapter \u2014 always returns success", tier: "pronto" },
+  // Admin
+  { id: "localStorage", name: "localStorage", domain: "admin", description: "Mock admin for prototyping", tier: "pronto" }
+];
+function getProvidersForDomain(domain) {
+  return PROVIDER_REGISTRY.filter((p) => p.domain === domain);
+}
+function getProviderMeta(domain, providerId) {
+  return PROVIDER_REGISTRY.find((p) => p.domain === domain && p.id === providerId);
+}
+
+// src/auth/localStorage.ts
+var USERS_KEY = "geenius_users";
+var SESSION_KEY = "geenius_session";
+function getUsers() {
+  try {
+    return JSON.parse(localStorage.getItem(USERS_KEY) || "[]");
+  } catch {
+    return [];
+  }
+}
+function saveUsers(users) {
+  localStorage.setItem(USERS_KEY, JSON.stringify(users));
+}
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+function createSession(userId) {
+  const session = {
+    userId,
+    token: crypto.randomUUID(),
+    expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3).toISOString()
+  };
+  localStorage.setItem(SESSION_KEY, JSON.stringify(session));
+  return session;
+}
+function createLocalStorageAuthAdapter() {
+  return {
+    async signInWithOAuth(provider, options) {
+      const mockEmail = `oauth-${provider}-user@example.com`;
+      const users = getUsers();
+      let user = users.find((u) => u.email === mockEmail);
+      if (!user) {
+        user = {
+          id: crypto.randomUUID(),
+          email: mockEmail,
+          name: `${provider.charAt(0).toUpperCase() + provider.slice(1)} User`,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          passwordHash: ""
+        };
+        users.push(user);
+        saveUsers(users);
+      }
+      createSession(user.id);
+      const redirectUrl = options?.redirectUrl || "/";
+      return { url: redirectUrl };
+    },
+    async signUp(email, password, name) {
+      const users = getUsers();
+      if (users.find((u) => u.email === email)) throw new AuthError("User already exists", "USER_EXISTS");
+      const user = {
+        id: crypto.randomUUID(),
+        email,
+        name: name || email.split("@")[0],
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        passwordHash: simpleHash(password)
+      };
+      users.push(user);
+      saveUsers(users);
+      return createSession(user.id);
+    },
+    async signIn(email, password) {
+      const user = getUsers().find((u) => u.email === email);
+      if (!user || user.passwordHash !== simpleHash(password)) {
+        throw new AuthError("Invalid email or password", "INVALID_CREDENTIALS");
+      }
+      return createSession(user.id);
+    },
+    async signOut() {
+      localStorage.removeItem(SESSION_KEY);
+    },
+    async getSession() {
+      try {
+        const raw = localStorage.getItem(SESSION_KEY);
+        if (!raw) return null;
+        const s = JSON.parse(raw);
+        if (!s || !s.expiresAt) return null;
+        if (new Date(s.expiresAt) < /* @__PURE__ */ new Date()) {
+          localStorage.removeItem(SESSION_KEY);
+          return null;
+        }
+        return s;
+      } catch {
+        return null;
+      }
+    },
+    async getUser() {
+      const session = await this.getSession();
+      if (!session) return null;
+      const stored = getUsers().find((u) => u.id === session.userId);
+      if (!stored) return null;
+      const { passwordHash: _, ...user } = stored;
+      return user;
+    },
+    async updateUser(updates) {
+      const session = await this.getSession();
+      if (!session) return null;
+      const users = getUsers();
+      const idx = users.findIndex((u) => u.id === session.userId);
+      if (idx === -1) return null;
+      Object.assign(users[idx], updates);
+      saveUsers(users);
+      const { passwordHash: _, ...user } = users[idx];
+      return user;
+    }
+  };
+}
+
+// src/db/memory.ts
+function matchesCondition(item, cond) {
+  const val = item[cond.field];
+  switch (cond.operator) {
+    case "eq":
+      return val === cond.value;
+    case "neq":
+      return val !== cond.value;
+    case "gt":
+      return val > cond.value;
+    case "gte":
+      return val >= cond.value;
+    case "lt":
+      return val < cond.value;
+    case "lte":
+      return val <= cond.value;
+    case "in":
+      return Array.isArray(cond.value) && cond.value.includes(val);
+    case "contains":
+      return typeof val === "string" && val.includes(cond.value);
+    default:
+      return false;
+  }
+}
+function matchesFilter(item, filter) {
+  return filter.every((cond) => matchesCondition(item, cond));
+}
+function createMemoryDbAdapter() {
+  const store = /* @__PURE__ */ new Map();
+  function getCollection2(collection) {
+    return store.get(collection) || [];
+  }
+  function saveCollection2(collection, data) {
+    store.set(collection, data);
+  }
+  return {
+    async create(collection, data) {
+      const items = getCollection2(collection);
+      const item = { ...data, id: crypto.randomUUID() };
+      items.push(item);
+      saveCollection2(collection, items);
+      return item;
+    },
+    async get(collection, id) {
+      const found = getCollection2(collection).find((item) => item.id === id);
+      return found ?? null;
+    },
+    async update(collection, id, data) {
+      const items = getCollection2(collection);
+      const idx = items.findIndex((item) => item.id === id);
+      if (idx === -1) return null;
+      Object.assign(items[idx], data);
+      saveCollection2(collection, items);
+      return items[idx];
+    },
+    async delete(collection, id) {
+      const items = getCollection2(collection);
+      const idx = items.findIndex((item) => item.id === id);
+      if (idx === -1) return false;
+      items.splice(idx, 1);
+      saveCollection2(collection, items);
+      return true;
+    },
+    async list(collection, options) {
+      let items = getCollection2(collection);
+      if (options?.orderBy) {
+        const dir = options.order === "desc" ? -1 : 1;
+        items.sort((a, b) => {
+          const av = a[options.orderBy], bv = b[options.orderBy];
+          return av < bv ? -dir : av > bv ? dir : 0;
+        });
+      }
+      if (options?.offset) items = items.slice(options.offset);
+      if (options?.limit) items = items.slice(0, options.limit);
+      return items;
+    },
+    async query(collection, filter) {
+      return getCollection2(collection).filter((item) => matchesFilter(item, filter));
+    },
+    async count(collection, filter) {
+      const items = getCollection2(collection);
+      if (!filter || filter.length === 0) return items.length;
+      return items.filter((item) => matchesFilter(item, filter)).length;
+    }
+  };
+}
+
+// src/db/localStorage.ts
+var DB_PREFIX = "geenius_db_";
+function getCollection(collection) {
+  try {
+    return JSON.parse(localStorage.getItem(DB_PREFIX + collection) || "[]");
+  } catch {
+    return [];
+  }
+}
+function saveCollection(collection, data) {
+  localStorage.setItem(DB_PREFIX + collection, JSON.stringify(data));
+}
+function matchesCondition2(item, cond) {
+  const val = item[cond.field];
+  switch (cond.operator) {
+    case "eq":
+      return val === cond.value;
+    case "neq":
+      return val !== cond.value;
+    case "gt":
+      return val > cond.value;
+    case "gte":
+      return val >= cond.value;
+    case "lt":
+      return val < cond.value;
+    case "lte":
+      return val <= cond.value;
+    case "in":
+      return Array.isArray(cond.value) && cond.value.includes(val);
+    case "contains":
+      return typeof val === "string" && val.includes(cond.value);
+    default:
+      return false;
+  }
+}
+function matchesFilter2(item, filter) {
+  return filter.every((cond) => matchesCondition2(item, cond));
+}
+function createLocalStorageDbAdapter() {
+  if (typeof window === "undefined") {
+    return createMemoryDbAdapter();
+  }
+  return {
+    async create(collection, data) {
+      const items = getCollection(collection);
+      const item = { ...data, id: crypto.randomUUID() };
+      items.push(item);
+      saveCollection(collection, items);
+      return item;
+    },
+    async get(collection, id) {
+      const found = getCollection(collection).find((item) => item.id === id);
+      return found ?? null;
+    },
+    async update(collection, id, data) {
+      const items = getCollection(collection);
+      const idx = items.findIndex((item) => item.id === id);
+      if (idx === -1) return null;
+      Object.assign(items[idx], data);
+      saveCollection(collection, items);
+      return items[idx];
+    },
+    async delete(collection, id) {
+      const items = getCollection(collection);
+      const idx = items.findIndex((item) => item.id === id);
+      if (idx === -1) return false;
+      items.splice(idx, 1);
+      saveCollection(collection, items);
+      return true;
+    },
+    async list(collection, options) {
+      let items = getCollection(collection);
+      if (options?.orderBy) {
+        const dir = options.order === "desc" ? -1 : 1;
+        items.sort((a, b) => {
+          const av = a[options.orderBy], bv = b[options.orderBy];
+          return av < bv ? -dir : av > bv ? dir : 0;
+        });
+      }
+      if (options?.offset) items = items.slice(options.offset);
+      if (options?.limit) items = items.slice(0, options.limit);
+      return items;
+    },
+    async query(collection, filter) {
+      return getCollection(collection).filter((item) => matchesFilter2(item, filter));
+    },
+    async count(collection, filter) {
+      const items = getCollection(collection);
+      if (!filter || filter.length === 0) return items.length;
+      return items.filter((item) => matchesFilter2(item, filter)).length;
+    }
+  };
+}
+
+// src/db/convex.ts
+function createConvexDbAdapter(options) {
+  const { client, functions } = options;
+  function getFns(collection) {
+    const fns = functions[collection];
+    if (!fns) throw new DbError(`No Convex functions configured for collection: ${collection}`, "COLLECTION_NOT_CONFIGURED");
+    return fns;
+  }
+  function matchesFilter4(item, filter) {
+    return filter.every((cond) => {
+      const val = item[cond.field];
+      switch (cond.operator) {
+        case "eq":
+          return val === cond.value;
+        case "neq":
+          return val !== cond.value;
+        case "gt":
+          return val > cond.value;
+        case "gte":
+          return val >= cond.value;
+        case "lt":
+          return val < cond.value;
+        case "lte":
+          return val <= cond.value;
+        case "in":
+          return Array.isArray(cond.value) && cond.value.includes(val);
+        case "contains":
+          return typeof val === "string" && val.includes(cond.value);
+        default:
+          return false;
+      }
+    });
+  }
+  return {
+    async create(collection, data) {
+      const fns = getFns(collection);
+      if (!fns.create) throw new DbError(`No create function for ${collection}`, "COLLECTION_NOT_CONFIGURED");
+      const id = await client.mutation(fns.create, data);
+      return { ...data, id };
+    },
+    async get(collection, id) {
+      const fns = getFns(collection);
+      if (!fns.get) throw new DbError(`No get function for ${collection}`, "COLLECTION_NOT_CONFIGURED");
+      const doc = await client.query(fns.get, { id });
+      if (!doc) return null;
+      return { ...doc, id: doc._id || id };
+    },
+    async update(collection, id, data) {
+      const fns = getFns(collection);
+      if (!fns.update) throw new DbError(`No update function for ${collection}`, "COLLECTION_NOT_CONFIGURED");
+      await client.mutation(fns.update, { id, ...data });
+      return this.get(collection, id);
+    },
+    async delete(collection, id) {
+      const fns = getFns(collection);
+      if (!fns.delete) throw new DbError(`No delete function for ${collection}`, "COLLECTION_NOT_CONFIGURED");
+      try {
+        await client.mutation(fns.delete, { id });
+        return true;
+      } catch (err) {
+        throw new DbError(`Delete from "${collection}" failed`, "QUERY_ERROR", err);
+      }
+    },
+    async list(collection, options2) {
+      const fns = getFns(collection);
+      if (!fns.list) throw new DbError(`No list function for ${collection}`, "COLLECTION_NOT_CONFIGURED");
+      const docs = await client.query(fns.list, {
+        limit: options2?.limit,
+        offset: options2?.offset,
+        orderBy: options2?.orderBy,
+        order: options2?.order
+      });
+      return (docs || []).map((d) => ({ ...d, id: d._id || d.id }));
+    },
+    async query(collection, filter) {
+      const fns = getFns(collection);
+      if (!fns.query) {
+        const all = await this.list(collection);
+        return all.filter((item) => matchesFilter4(item, filter));
+      }
+      const docs = await client.query(fns.query, { filter });
+      return (docs || []).map((d) => ({ ...d, id: d._id || d.id }));
+    },
+    async count(collection, filter) {
+      const fns = getFns(collection);
+      if (fns.count) {
+        return client.query(fns.count, filter ? { filter } : void 0);
+      }
+      const items = filter ? await this.query(collection, filter) : await this.list(collection);
+      return items.length;
+    }
+  };
+}
+
+// src/db/neon.ts
+function createNeonDbAdapter(options) {
+  const { client, tables, operators: ops } = options;
+  function getTable(collection) {
+    const table = tables[collection];
+    if (!table) throw new DbError(`No table configured for collection: ${collection}`, "COLLECTION_NOT_CONFIGURED");
+    return table;
+  }
+  function buildConditions(table, filter) {
+    return filter.map((cond) => {
+      const col = table[cond.field];
+      if (!col) throw new DbError(`Column ${cond.field} not found in table`, "QUERY_ERROR");
+      switch (cond.operator) {
+        case "eq":
+          return ops.eq(col, cond.value);
+        case "neq":
+          return ops.ne(col, cond.value);
+        case "gt":
+          return ops.gt(col, cond.value);
+        case "gte":
+          return ops.gte(col, cond.value);
+        case "lt":
+          return ops.lt(col, cond.value);
+        case "lte":
+          return ops.lte(col, cond.value);
+        case "in":
+          return ops.inArray(col, cond.value);
+        case "contains":
+          return ops.like(col, `%${cond.value}%`);
+        default:
+          throw new DbError(`Unsupported operator: ${cond.operator}`, "QUERY_ERROR");
+      }
+    });
+  }
+  return {
+    async create(collection, data) {
+      const table = getTable(collection);
+      try {
+        const [result] = await client.insert(table).values(data).returning();
+        return result;
+      } catch (err) {
+        throw new DbError(`Insert into "${collection}" failed`, "QUERY_ERROR", err);
+      }
+    },
+    async get(collection, id) {
+      const table = getTable(collection);
+      try {
+        const [result] = await client.select().from(table).where(ops.eq(table.id, id)).limit(1);
+        return result ?? null;
+      } catch (err) {
+        throw new DbError(`Get from "${collection}" failed`, "QUERY_ERROR", err);
+      }
+    },
+    async update(collection, id, data) {
+      const table = getTable(collection);
+      try {
+        const [result] = await client.update(table).set(data).where(ops.eq(table.id, id)).returning();
+        return result ?? null;
+      } catch (err) {
+        throw new DbError(`Update in "${collection}" failed`, "QUERY_ERROR", err);
+      }
+    },
+    async delete(collection, id) {
+      const table = getTable(collection);
+      try {
+        const result = await client.delete(table).where(ops.eq(table.id, id)).returning();
+        return Array.isArray(result) && result.length > 0;
+      } catch (err) {
+        throw new DbError(`Delete from "${collection}" failed`, "QUERY_ERROR", err);
+      }
+    },
+    async list(collection, options2) {
+      const table = getTable(collection);
+      let query = client.select().from(table);
+      if (options2?.orderBy) {
+        const col = table[options2.orderBy];
+        if (col) {
+          query = query.orderBy(options2.order === "desc" ? ops.desc(col) : ops.asc(col));
+        }
+      }
+      if (options2?.limit) query = query.limit(options2.limit);
+      if (options2?.offset) query = query.offset(options2.offset);
+      return query;
+    },
+    async query(collection, filter) {
+      const table = getTable(collection);
+      if (filter.length === 0) {
+        return client.select().from(table);
+      }
+      const conditions = buildConditions(table, filter);
+      return client.select().from(table).where(ops.and(...conditions));
+    },
+    async count(collection, filter) {
+      const table = getTable(collection);
+      if (!filter || filter.length === 0) {
+        const [result2] = await client.select({ count: ops.count() }).from(table);
+        return Number(result2?.count ?? 0);
+      }
+      const conditions = buildConditions(table, filter);
+      const [result] = await client.select({ count: ops.count() }).from(table).where(ops.and(...conditions));
+      return Number(result?.count ?? 0);
+    }
+  };
+}
+
+// src/db/supabase.ts
+function createSupabaseDbAdapter(options) {
+  const { client, tableNames = {} } = options;
+  function tableName(collection) {
+    return tableNames[collection] || collection;
+  }
+  return {
+    async create(collection, data) {
+      const { data: result, error } = await client.from(tableName(collection)).insert(data).select().single();
+      if (error) throw new DbError(`Insert into "${collection}" failed: ${error.message}`, "QUERY_ERROR", error);
+      return result;
+    },
+    async get(collection, id) {
+      const { data, error } = await client.from(tableName(collection)).select().eq("id", id).single();
+      if (error) return null;
+      return data;
+    },
+    async update(collection, id, data) {
+      const { data: result, error } = await client.from(tableName(collection)).update(data).eq("id", id).select().single();
+      if (error) return null;
+      return result;
+    },
+    async delete(collection, id) {
+      const { error } = await client.from(tableName(collection)).delete().eq("id", id);
+      return !error;
+    },
+    async list(collection, options2) {
+      let query = client.from(tableName(collection)).select();
+      if (options2?.orderBy) {
+        query = query.order(options2.orderBy, {
+          ascending: options2.order !== "desc"
+        });
+      }
+      if (options2?.offset !== void 0 && options2?.limit !== void 0) {
+        query = query.range(options2.offset, options2.offset + options2.limit - 1);
+      } else if (options2?.limit) {
+        query = query.limit(options2.limit);
+      }
+      const { data, error } = await query;
+      if (error) throw new DbError(`List "${collection}" failed: ${error.message}`, "QUERY_ERROR", error);
+      return data || [];
+    },
+    async query(collection, filter) {
+      let query = client.from(tableName(collection)).select();
+      for (const cond of filter) {
+        switch (cond.operator) {
+          case "eq":
+            query = query.eq(cond.field, cond.value);
+            break;
+          case "neq":
+            query = query.neq(cond.field, cond.value);
+            break;
+          case "gt":
+            query = query.gt(cond.field, cond.value);
+            break;
+          case "gte":
+            query = query.gte(cond.field, cond.value);
+            break;
+          case "lt":
+            query = query.lt(cond.field, cond.value);
+            break;
+          case "lte":
+            query = query.lte(cond.field, cond.value);
+            break;
+          case "in":
+            query = query.in(cond.field, cond.value);
+            break;
+          case "contains":
+            query = query.ilike(cond.field, `%${cond.value}%`);
+            break;
+        }
+      }
+      const { data, error } = await query;
+      if (error) throw new DbError(`Query "${collection}" failed: ${error.message}`, "QUERY_ERROR", error);
+      return data || [];
+    },
+    async count(collection, filter) {
+      if (!filter || filter.length === 0) {
+        const { data } = await client.from(tableName(collection)).select("id");
+        return data?.length ?? 0;
+      }
+      const items = await this.query(collection, filter);
+      return items.length;
+    }
+  };
+}
+
+// src/db/mongodb.ts
+function createMongoDbAdapter(options) {
+  const { db, collectionNames = {} } = options;
+  function col(collection) {
+    return db.collection(collectionNames[collection] || collection);
+  }
+  function buildMongoFilter(filter) {
+    const mongoFilter = {};
+    for (const cond of filter) {
+      switch (cond.operator) {
+        case "eq":
+          mongoFilter[cond.field] = cond.value;
+          break;
+        case "neq":
+          mongoFilter[cond.field] = { $ne: cond.value };
+          break;
+        case "gt":
+          mongoFilter[cond.field] = { $gt: cond.value };
+          break;
+        case "gte":
+          mongoFilter[cond.field] = { $gte: cond.value };
+          break;
+        case "lt":
+          mongoFilter[cond.field] = { $lt: cond.value };
+          break;
+        case "lte":
+          mongoFilter[cond.field] = { $lte: cond.value };
+          break;
+        case "in":
+          mongoFilter[cond.field] = { $in: cond.value };
+          break;
+        case "contains":
+          mongoFilter[cond.field] = { $regex: cond.value, $options: "i" };
+          break;
+      }
+    }
+    return mongoFilter;
+  }
+  function stripMongoId(doc) {
+    const { _id, ...rest } = doc;
+    return rest;
+  }
+  return {
+    async create(collection, data) {
+      const id = crypto.randomUUID();
+      const doc = { ...data, id };
+      try {
+        await col(collection).insertOne(doc);
+      } catch (err) {
+        throw new DbError(`Insert into "${collection}" failed`, "QUERY_ERROR", err);
+      }
+      return doc;
+    },
+    async get(collection, id) {
+      const doc = await col(collection).findOne({ id });
+      if (!doc) return null;
+      return stripMongoId(doc);
+    },
+    async update(collection, id, data) {
+      try {
+        await col(collection).updateOne({ id }, { $set: data });
+      } catch (err) {
+        throw new DbError(`Update in "${collection}" failed`, "QUERY_ERROR", err);
+      }
+      return this.get(collection, id);
+    },
+    async delete(collection, id) {
+      const result = await col(collection).deleteOne({ id });
+      return result.deletedCount > 0;
+    },
+    async list(collection, options2) {
+      let cursor = col(collection).find();
+      if (options2?.orderBy) {
+        cursor = cursor.sort({ [options2.orderBy]: options2.order === "desc" ? -1 : 1 });
+      }
+      if (options2?.offset) cursor = cursor.skip(options2.offset);
+      if (options2?.limit) cursor = cursor.limit(options2.limit);
+      const docs = await cursor.toArray();
+      return docs.map(stripMongoId);
+    },
+    async query(collection, filter) {
+      const mongoFilter = buildMongoFilter(filter);
+      const docs = await col(collection).find(mongoFilter).toArray();
+      return docs.map(stripMongoId);
+    },
+    async count(collection, filter) {
+      const mongoFilter = filter ? buildMongoFilter(filter) : {};
+      return col(collection).countDocuments(mongoFilter);
+    }
+  };
+}
+
+// src/db/cloudflareKV.ts
+var DB_PREFIX2 = "geenius_db_";
+function matchesCondition3(item, cond) {
+  const val = item[cond.field];
+  switch (cond.operator) {
+    case "eq":
+      return val === cond.value;
+    case "neq":
+      return val !== cond.value;
+    case "gt":
+      return val > cond.value;
+    case "gte":
+      return val >= cond.value;
+    case "lt":
+      return val < cond.value;
+    case "lte":
+      return val <= cond.value;
+    case "in":
+      return Array.isArray(cond.value) && cond.value.includes(val);
+    case "contains":
+      return typeof val === "string" && val.includes(cond.value);
+    default:
+      return false;
+  }
+}
+function matchesFilter3(item, filter) {
+  return filter.every((cond) => matchesCondition3(item, cond));
+}
+function createCloudflareKVDbAdapter(kv) {
+  async function getCollection2(collection) {
+    try {
+      const data = await kv.get(DB_PREFIX2 + collection, "json");
+      return data || [];
+    } catch (err) {
+      throw new DbError(`Failed to read collection "${collection}" from KV`, "CONNECTION_ERROR", err);
+    }
+  }
+  async function saveCollection2(collection, data) {
+    try {
+      await kv.put(DB_PREFIX2 + collection, JSON.stringify(data));
+    } catch (err) {
+      throw new DbError(`Failed to write collection "${collection}" to KV`, "CONNECTION_ERROR", err);
+    }
+  }
+  return {
+    async create(collection, data) {
+      const items = await getCollection2(collection);
+      const item = { ...data, id: crypto.randomUUID() };
+      items.push(item);
+      await saveCollection2(collection, items);
+      return item;
+    },
+    async get(collection, id) {
+      const items = await getCollection2(collection);
+      const found = items.find((item) => item.id === id);
+      return found ?? null;
+    },
+    async update(collection, id, data) {
+      const items = await getCollection2(collection);
+      const idx = items.findIndex((item) => item.id === id);
+      if (idx === -1) return null;
+      Object.assign(items[idx], data);
+      await saveCollection2(collection, items);
+      return items[idx];
+    },
+    async delete(collection, id) {
+      const items = await getCollection2(collection);
+      const idx = items.findIndex((item) => item.id === id);
+      if (idx === -1) return false;
+      items.splice(idx, 1);
+      await saveCollection2(collection, items);
+      return true;
+    },
+    async list(collection, options) {
+      let items = await getCollection2(collection);
+      if (options?.orderBy) {
+        const dir = options.order === "desc" ? -1 : 1;
+        items.sort((a, b) => {
+          const av = a[options.orderBy], bv = b[options.orderBy];
+          return av < bv ? -dir : av > bv ? dir : 0;
+        });
+      }
+      if (options?.offset) items = items.slice(options.offset);
+      if (options?.limit) items = items.slice(0, options.limit);
+      return items;
+    },
+    async query(collection, filter) {
+      const items = await getCollection2(collection);
+      return items.filter((item) => matchesFilter3(item, filter));
+    },
+    async count(collection, filter) {
+      const items = await getCollection2(collection);
+      if (!filter || filter.length === 0) return items.length;
+      return items.filter((item) => matchesFilter3(item, filter)).length;
+    }
+  };
+}
+
+// src/payments/localStorage.ts
+var SUBS_KEY = "geenius_subscriptions";
+var PLANS_KEY = "geenius_plans";
+var DEFAULT_PLANS = [
+  { id: "free", name: "Free", price: 0, currency: "USD", interval: "month", features: ["Basic features", "1 project", "Community support"] },
+  { id: "pro", name: "Pro", price: 29, currency: "USD", interval: "month", features: ["All Free features", "Unlimited projects", "Priority support", "AI features"] },
+  { id: "team", name: "Team", price: 79, currency: "USD", interval: "month", features: ["All Pro features", "Team management", "Admin dashboard", "Custom integrations"] }
+];
+function getSubs() {
+  try {
+    return JSON.parse(localStorage.getItem(SUBS_KEY) || "[]");
+  } catch {
+    return [];
+  }
+}
+function saveSubs(subs) {
+  localStorage.setItem(SUBS_KEY, JSON.stringify(subs));
+}
+function createLocalStoragePaymentsAdapter() {
+  if (!localStorage.getItem(PLANS_KEY)) {
+    localStorage.setItem(PLANS_KEY, JSON.stringify(DEFAULT_PLANS));
+  }
+  return {
+    async createCheckout(params) {
+      const subs = getSubs();
+      const sub = {
+        id: crypto.randomUUID(),
+        userId: params.userId,
+        planId: params.planId,
+        status: "active",
+        currentPeriodEnd: new Date(Date.now() + 30 * 24 * 60 * 60 * 1e3).toISOString(),
+        cancelAtPeriodEnd: false
+      };
+      subs.push(sub);
+      saveSubs(subs);
+      return { url: params.successUrl || "/", sessionId: sub.id };
+    },
+    async getSubscription(userId) {
+      const sub = getSubs().find((s) => s.userId === userId && s.status === "active");
+      return sub ?? null;
+    },
+    async cancelSubscription(subscriptionId) {
+      const subs = getSubs();
+      const idx = subs.findIndex((s) => s.id === subscriptionId);
+      if (idx !== -1) {
+        subs[idx].cancelAtPeriodEnd = true;
+        subs[idx].status = "cancelled";
+        saveSubs(subs);
+      }
+    },
+    async getPlans() {
+      try {
+        return JSON.parse(localStorage.getItem(PLANS_KEY) || "[]");
+      } catch {
+        return DEFAULT_PLANS;
+      }
+    },
+    async isFeatureEnabled(userId, feature) {
+      const sub = await this.getSubscription(userId);
+      if (!sub) return false;
+      const plans = await this.getPlans();
+      const plan = plans.find((p) => p.id === sub.planId);
+      return plan?.features.includes(feature) ?? false;
+    }
+  };
+}
+function createNoopPaymentsAdapter() {
+  return {
+    async createCheckout() {
+      throw new Error("Payments not available in Pronto tier. Upgrade to Lancio.");
+    },
+    async getSubscription() {
+      return null;
+    },
+    async cancelSubscription() {
+    },
+    async getPlans() {
+      return [];
+    },
+    async isFeatureEnabled() {
+      return false;
+    }
+  };
+}
+
+// src/ai/localStorage.ts
+var HISTORY_KEY = "geenius_ai_history";
+var CANNED_RESPONSES = [
+  "That's an interesting question! In the Pronto tier, AI responses are simulated. Upgrade to MVP for real AI.",
+  "I'm a mock AI assistant. I can demonstrate the chat interface, but for real responses you'll need the MVP tier.",
+  "Great question! This is a localStorage-based AI mock. The real AI adapter connects to OpenAI/Anthropic APIs.",
+  "I appreciate your input! This demo shows how the AI interface works. Upgrade for actual AI capabilities.",
+  "Interesting! While I can't provide real AI analysis in Pronto, this shows the adapter pattern in action."
+];
+function getCannedResponse(messages) {
+  const lastMsg = messages[messages.length - 1]?.content || "";
+  let hash = 0;
+  for (let i = 0; i < lastMsg.length; i++) {
+    hash = (hash << 5) - hash + lastMsg.charCodeAt(i);
+    hash |= 0;
+  }
+  return CANNED_RESPONSES[Math.abs(hash) % CANNED_RESPONSES.length];
+}
+function saveToHistory(messages, response) {
+  try {
+    const history = JSON.parse(localStorage.getItem(HISTORY_KEY) || "[]");
+    history.push({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), messages, response });
+    if (history.length > 50) history.splice(0, history.length - 50);
+    localStorage.setItem(HISTORY_KEY, JSON.stringify(history));
+  } catch {
+  }
+}
+function createLocalStorageAiAdapter() {
+  return {
+    async chat(messages, _options) {
+      await new Promise((r) => setTimeout(r, 300 + Math.random() * 700));
+      const content = getCannedResponse(messages);
+      saveToHistory(messages, content);
+      return {
+        content,
+        finishReason: "stop",
+        usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 }
+      };
+    },
+    async complete(prompt, options) {
+      const response = await this.chat([{ role: "user", content: prompt }], options);
+      return response.content;
+    },
+    async embed(text) {
+      const inputs = Array.isArray(text) ? text : [text];
+      return inputs.map((t) => {
+        const vec = [];
+        for (let i = 0; i < 8; i++) {
+          let h = i * 31;
+          for (let j = 0; j < t.length; j++) {
+            h = (h << 5) - h + t.charCodeAt(j);
+            h |= 0;
+          }
+          vec.push(Math.sin(h) * 0.5 + 0.5);
+        }
+        return vec;
+      });
+    },
+    async *stream(messages, _options) {
+      const content = getCannedResponse(messages);
+      saveToHistory(messages, content);
+      const words = content.split(" ");
+      for (const word of words) {
+        await new Promise((r) => setTimeout(r, 40 + Math.random() * 60));
+        yield word + " ";
+      }
+    }
+  };
+}
+
+// src/storage/localStorage.ts
+var FILES_KEY = "geenius_files";
+var BLOBS_PREFIX = "geenius_blob_";
+function getFiles() {
+  try {
+    return JSON.parse(localStorage.getItem(FILES_KEY) || "[]");
+  } catch {
+    return [];
+  }
+}
+function saveFiles(files) {
+  localStorage.setItem(FILES_KEY, JSON.stringify(files));
+}
+function blobToBase64(blob) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = reject;
+    reader.readAsDataURL(blob);
+  });
+}
+function base64ToBlob(dataUrl) {
+  const [meta, data] = dataUrl.split(",");
+  const mime = meta.match(/:(.*?);/)?.[1] || "application/octet-stream";
+  const bytes = atob(data);
+  const buffer = new Uint8Array(bytes.length);
+  for (let i = 0; i < bytes.length; i++) buffer[i] = bytes.charCodeAt(i);
+  return new Blob([buffer], { type: mime });
+}
+function createLocalStorageFileAdapter() {
+  return {
+    async upload(file, path, name) {
+      const base64 = await blobToBase64(file);
+      const id = crypto.randomUUID();
+      const blobKey = BLOBS_PREFIX + id;
+      localStorage.setItem(blobKey, base64);
+      const entry = {
+        id,
+        name: name || (file instanceof File ? file.name : `file-${id.slice(0, 8)}`),
+        path,
+        size: file.size,
+        mimeType: file.type || "application/octet-stream",
+        url: `local://${id}`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        blobKey
+      };
+      const files = getFiles();
+      files.push(entry);
+      saveFiles(files);
+      const { blobKey: _, ...storedFile } = entry;
+      return storedFile;
+    },
+    async download(fileId) {
+      const entry = getFiles().find((f) => f.id === fileId);
+      if (!entry) throw new Error(`File not found: ${fileId}`);
+      const base64 = localStorage.getItem(entry.blobKey);
+      if (!base64) throw new Error(`Blob data missing for file: ${fileId}`);
+      return base64ToBlob(base64);
+    },
+    async delete(fileId) {
+      const files = getFiles();
+      const idx = files.findIndex((f) => f.id === fileId);
+      if (idx === -1) return false;
+      localStorage.removeItem(files[idx].blobKey);
+      files.splice(idx, 1);
+      saveFiles(files);
+      return true;
+    },
+    async list(prefix) {
+      let files = getFiles();
+      if (prefix) files = files.filter((f) => f.path.startsWith(prefix));
+      return files.map(({ blobKey: _, ...f }) => f);
+    },
+    async getUrl(fileId) {
+      const entry = getFiles().find((f) => f.id === fileId);
+      if (!entry) throw new Error(`File not found: ${fileId}`);
+      const base64 = localStorage.getItem(entry.blobKey);
+      return base64 || entry.url;
+    }
+  };
+}
+
+// src/admin/localStorage.ts
+var USERS_KEY2 = "geenius_auth_users";
+function createLocalStorageAdminAdapter() {
+  function getUsers2() {
+    try {
+      const data = localStorage.getItem(USERS_KEY2);
+      if (!data) return [];
+      const raw = JSON.parse(data);
+      return Object.values(raw).map((u) => ({
+        id: u.id,
+        email: u.email,
+        name: u.name,
+        image: u.image,
+        role: u.role || "user",
+        isActive: true,
+        isBanned: u.isBanned || false,
+        plan: u.plan || "free",
+        createdAt: u.createdAt,
+        lastLoginAt: u.lastLoginAt
+      }));
+    } catch {
+      return [];
+    }
+  }
+  return {
+    async listUsers(options) {
+      let users = getUsers2();
+      if (options?.search) {
+        const q = options.search.toLowerCase();
+        users = users.filter(
+          (u) => u.email?.toLowerCase().includes(q) || u.name?.toLowerCase().includes(q)
+        );
+      }
+      const offset = options?.offset || 0;
+      const limit = options?.limit || 50;
+      return users.slice(offset, offset + limit);
+    },
+    async getUser(id) {
+      const users = getUsers2();
+      return users.find((u) => u.id === id) || null;
+    },
+    async banUser(id) {
+      try {
+        const data = JSON.parse(localStorage.getItem(USERS_KEY2) || "{}");
+        if (data[id]) {
+          data[id].isBanned = true;
+          localStorage.setItem(USERS_KEY2, JSON.stringify(data));
+          return true;
+        }
+        return false;
+      } catch {
+        return false;
+      }
+    },
+    async unbanUser(id) {
+      try {
+        const data = JSON.parse(localStorage.getItem(USERS_KEY2) || "{}");
+        if (data[id]) {
+          data[id].isBanned = false;
+          localStorage.setItem(USERS_KEY2, JSON.stringify(data));
+          return true;
+        }
+        return false;
+      } catch {
+        return false;
+      }
+    },
+    async deleteUser(id) {
+      try {
+        const data = JSON.parse(localStorage.getItem(USERS_KEY2) || "{}");
+        if (data[id]) {
+          delete data[id];
+          localStorage.setItem(USERS_KEY2, JSON.stringify(data));
+          return true;
+        }
+        return false;
+      } catch {
+        return false;
+      }
+    },
+    async getMetrics() {
+      const users = getUsers2();
+      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const newToday = users.filter(
+        (u) => u.createdAt && u.createdAt.startsWith(today)
+      ).length;
+      return {
+        totalUsers: users.length,
+        activeUsers: users.filter((u) => u.isActive && !u.isBanned).length,
+        newUsersToday: newToday
+      };
+    }
+  };
+}
+
+// src/tier-gate.ts
+var DEFAULT_TIER_GATE = {
+  features: {
+    pronto: [
+      "auth",
+      "i18n",
+      "ai-chat"
+    ],
+    lancio: [
+      "auth",
+      "i18n",
+      "ai-chat",
+      "admin",
+      "payments",
+      "blog",
+      "file-storage",
+      "ai-workflow",
+      "ai-embeddings"
+    ],
+    studio: [
+      "auth",
+      "i18n",
+      "ai-chat",
+      "admin",
+      "payments",
+      "blog",
+      "file-storage",
+      "ai-workflow",
+      "ai-embeddings",
+      "ai-magic",
+      "analytics",
+      "emails",
+      "teams",
+      "feature-flags",
+      "docs",
+      "monitoring",
+      "notifications",
+      "jobs",
+      "changelog",
+      "roadmap",
+      "waitlist",
+      "seo",
+      "onboarding",
+      "feedback",
+      "pricing",
+      "search"
+    ]
+  },
+  packages: {
+    pronto: [
+      "@geenius/adapters",
+      "@geenius/auth",
+      "@geenius/i18n",
+      "@geenius/config",
+      "@geenius/tools",
+      "@geenius/ui"
+    ],
+    lancio: [
+      "@geenius/adapters",
+      "@geenius/auth",
+      "@geenius/i18n",
+      "@geenius/config",
+      "@geenius/tools",
+      "@geenius/ui",
+      "@geenius/admin",
+      "@geenius/payments",
+      "@geenius/stripe",
+      "@geenius/blog",
+      "@geenius/file-storage",
+      "@geenius/ai"
+    ],
+    studio: [
+      "@geenius/adapters",
+      "@geenius/auth",
+      "@geenius/i18n",
+      "@geenius/config",
+      "@geenius/tools",
+      "@geenius/ui",
+      "@geenius/admin",
+      "@geenius/payments",
+      "@geenius/stripe",
+      "@geenius/blog",
+      "@geenius/file-storage",
+      "@geenius/ai",
+      "@geenius/ai-magic",
+      "@geenius/ai-workflow",
+      "@geenius/analytics",
+      "@geenius/emails",
+      "@geenius/teams",
+      "@geenius/feature-flags",
+      "@geenius/docs",
+      "@geenius/monitoring",
+      "@geenius/notifications",
+      "@geenius/jobs",
+      "@geenius/changelog",
+      "@geenius/roadmap",
+      "@geenius/waitlist",
+      "@geenius/seo",
+      "@geenius/onboarding",
+      "@geenius/feedback",
+      "@geenius/pricing",
+      "@geenius/search",
+      "@geenius/agent"
+    ]
+  }
+};
+function isFeatureAvailable(feature, tier) {
+  return DEFAULT_TIER_GATE.features[tier]?.includes(feature) ?? false;
+}
+function isPackageAvailable(pkg, tier) {
+  return DEFAULT_TIER_GATE.packages[tier]?.includes(pkg) ?? false;
+}
+function getAvailableFeatures(tier) {
+  return DEFAULT_TIER_GATE.features[tier] || [];
+}
+function getAvailablePackages(tier) {
+  return DEFAULT_TIER_GATE.packages[tier] || [];
+}
+function getUpgradeFeatures(currentTier, targetTier) {
+  const current = new Set(DEFAULT_TIER_GATE.features[currentTier] || []);
+  const target = DEFAULT_TIER_GATE.features[targetTier] || [];
+  return target.filter((f) => !current.has(f));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ADAPTER_DOMAINS,
+  ADAPTER_STATUSES,
+  ADMIN_PROVIDERS,
+  AI_PROVIDERS,
+  AUTH_PROVIDERS,
+  AdapterError,
+  AdminError,
+  AiError,
+  AuthError,
+  DB_PROVIDERS,
+  DEFAULT_TIER_GATE,
+  DOMAIN_DESCRIPTIONS,
+  DOMAIN_ICONS,
+  DOMAIN_LABELS,
+  DbError,
+  PAYMENT_PROVIDERS,
+  PROVIDER_REGISTRY,
+  PaymentsError,
+  STORAGE_PROVIDERS,
+  StorageError,
+  clearResolvers,
+  configureAdapters,
+  createCloudflareKVDbAdapter,
+  createConvexDbAdapter,
+  createLocalStorageAdminAdapter,
+  createLocalStorageAiAdapter,
+  createLocalStorageAuthAdapter,
+  createLocalStorageDbAdapter,
+  createLocalStorageFileAdapter,
+  createLocalStoragePaymentsAdapter,
+  createMemoryDbAdapter,
+  createMongoDbAdapter,
+  createNeonDbAdapter,
+  createNoopPaymentsAdapter,
+  createSupabaseDbAdapter,
+  getAdapterConfig,
+  getAvailableFeatures,
+  getAvailablePackages,
+  getDomainConfig,
+  getProviderMeta,
+  getProvidersForDomain,
+  getUpgradeFeatures,
+  hasResolver,
+  isAdapterError,
+  isAdaptersConfigured,
+  isFeatureAvailable,
+  isPackageAvailable,
+  isRetryable,
+  registerResolver,
+  resetAdapterConfig,
+  resolveAdapter,
+  withRetry
+});
+//# sourceMappingURL=index.js.map