@aurabase/aurabase-js 0.3.0

package/packages/ai/tests/sse.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from 'vitest'
+import { parseSSE } from '../src/sse'
+
+/** Construit un ReadableStream<Uint8Array> à partir de fragments texte arbitraires. */
+function streamOf(chunks: string[]): ReadableStream<Uint8Array> {
+  const enc = new TextEncoder()
+  let i = 0
+  return new ReadableStream<Uint8Array>({
+    pull(controller) {
+      if (i < chunks.length) controller.enqueue(enc.encode(chunks[i++]))
+      else controller.close()
+    },
+  })
+}
+
+async function collect(stream: ReadableStream<Uint8Array>) {
+  const out: Array<{ event: string; data: string }> = []
+  for await (const msg of parseSSE(stream)) out.push(msg)
+  return out
+}
+
+describe('parseSSE', () => {
+  it('parse un event simple (event + data)', async () => {
+    const got = await collect(streamOf(['event: delta\ndata: hello\n\n']))
+    expect(got).toEqual([{ event: 'delta', data: 'hello' }])
+  })
+
+  it('event scindé sur deux chunks (trame partielle)', async () => {
+    // La coupure tombe au milieu du champ data.
+    const got = await collect(streamOf(['event: delta\ndata: hel', 'lo\n\n']))
+    expect(got).toEqual([{ event: 'delta', data: 'hello' }])
+  })
+
+  it('plusieurs data: par event → jointes par \\n', async () => {
+    const got = await collect(streamOf(['event: delta\ndata: line1\ndata: line2\n\n']))
+    expect(got).toEqual([{ event: 'delta', data: 'line1\nline2' }])
+  })
+
+  it('plusieurs events dans un même chunk', async () => {
+    const got = await collect(
+      streamOf(['event: delta\ndata: a\n\nevent: delta\ndata: b\n\nevent: done\ndata: [DONE]\n\n']),
+    )
+    expect(got).toEqual([
+      { event: 'delta', data: 'a' },
+      { event: 'delta', data: 'b' },
+      { event: 'done', data: '[DONE]' },
+    ])
+  })
+
+  it('ignore les lignes keep-alive (commentaires « : … »)', async () => {
+    const got = await collect(streamOf([': keep-alive ping\n\nevent: delta\ndata: x\n\n']))
+    expect(got).toEqual([{ event: 'delta', data: 'x' }])
+  })
+
+  it('event: done est reconnu et livré', async () => {
+    const got = await collect(streamOf(['event: done\ndata: [DONE]\n\n']))
+    expect(got.at(-1)).toEqual({ event: 'done', data: '[DONE]' })
+  })
+
+  it('tolère les fins de ligne CRLF', async () => {
+    const got = await collect(streamOf(['event: delta\r\ndata: crlf\r\n\r\n']))
+    expect(got).toEqual([{ event: 'delta', data: 'crlf' }])
+  })
+
+  it('event final sans ligne vide terminale est tout de même livré', async () => {
+    const got = await collect(streamOf(['event: delta\ndata: tail']))
+    expect(got).toEqual([{ event: 'delta', data: 'tail' }])
+  })
+})

package/packages/ai/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": { "outDir": "dist", "rootDir": "src" },
+  "include": ["src"]
+}

package/packages/ai/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  splitting: false,
+  clean: true,
+  treeshake: true,
+  minify: false,
+})

package/packages/aurabase/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aurabase
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/packages/aurabase/README.md

@@ -0,0 +1,64 @@
+# aurabase
+
+Client JavaScript/TypeScript officiel d'Aurabase : point d'entrée principal du SDK, agrégeant les 8 packages de service (`@aurabase/*`) derrière `createClient`/`createAdminClient` et l'export `aurabase/ssr`.
+
+![npm](https://img.shields.io/npm/v/aurabase) ![license](https://img.shields.io/badge/license-MIT-blue)
+
+> Pre-release — pas encore publié sur npm.
+
+## Installation
+
+```bash
+npm i aurabase
+```
+
+## Rôle
+
+Ce package ne réimplémente aucune logique de service : il compose `AuthService`, `DatabaseService`, `StorageService`, `RealtimeService`, `FunctionsService`, `AiService` et `NotificationsService` (chacun dans son propre package `@aurabase/*`) derrière un seul client.
+
+- `createClient(baseUrl, projectId, apiKey, options?)` — client applicatif standard.
+- `createAdminClient(baseUrl, projectId, serviceRoleKey, options?)` — client serveur avec `authAdmin` (clé `service_role`, jamais côté navigateur).
+- `aurabase/ssr` — `createServerClient`/`createBrowserClient` pour Next.js et frameworks SSR (cookies, session partagée serveur/navigateur).
+
+## Quick Start
+
+```ts
+import { createClient } from 'aurabase'
+
+const aura = createClient(
+  'http://localhost:8080',
+  '00000000-0000-0000-0000-000000000001',
+  'aura_anon_xxx',
+)
+
+const { data, error } = await aura.db
+  .from('posts')
+  .select('id,title,published')
+  .eq('published', true)
+  .order('created_at', 'desc')
+  .limit(10)
+
+if (error) {
+  console.error(error.code, error.message)
+}
+```
+
+## Sous-packages
+
+| Package | Contenu |
+|---|---|
+| [`@aurabase/core`](../core) | fetch, erreurs, types, stores, `BaseService`, interface `AuraClientLike` |
+| [`@aurabase/auth`](../auth) | `AuthService`, `AuthAdminService` |
+| [`@aurabase/db`](../db) | `DatabaseService`, `QueryBuilder` |
+| [`@aurabase/storage`](../storage) | `StorageService` |
+| [`@aurabase/realtime`](../realtime) | `RealtimeService`, `AuraChannel`, `HeartbeatManager` |
+| [`@aurabase/functions`](../functions) | `FunctionsService` |
+| [`@aurabase/ai`](../ai) | `AiService` |
+| [`@aurabase/notifications`](../notifications) | `NotificationsService`, `NotificationsAdminService` |
+| [`@aurabase/gen`](../gen) | générateur CLI de types `Database` (dev-dependency, non inclus dans `aurabase`) |
+
+Tous ces packages (hors `@aurabase/gen`) sont des dépendances directes de `aurabase` : les installer séparément n'est utile que pour du tree-shaking ciblé ou pour composer votre propre client.
+
+## Documentation
+
+Cette page ne couvre que le rôle du package d'agrégation. Documentation de référence complète : voir le [README du dépôt](../../README.md).

package/packages/aurabase/dist/AuraClient-DAtDbfPB.d.cts

@@ -0,0 +1,77 @@
+import { AuraClientLike, BaseAuthStore, AuraObservabilityEvent, AuraClientOptions, ChannelConfig } from '@aurabase/core';
+import { AuthService, AuthAdminService } from '@aurabase/auth';
+import { DatabaseService } from '@aurabase/db';
+import { StorageService } from '@aurabase/storage';
+import { RealtimeService, AuraChannel } from '@aurabase/realtime';
+import { FunctionsService } from '@aurabase/functions';
+import { AiService } from '@aurabase/ai';
+import { NotificationsService } from '@aurabase/notifications';
+
+/**
+ * Main Aurabase client.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'aurabase'
+ * const aura = createClient('http://localhost:8080', 'my-project-id')
+ * const { data } = await aura.db.from('posts').eq('published', true)
+ * ```
+ */
+declare class AuraClient<Database = any> implements AuraClientLike {
+    readonly baseUrl: string;
+    readonly projectId: string;
+    readonly apiKey: string | null;
+    readonly fetchFn: typeof globalThis.fetch;
+    readonly authStore: BaseAuthStore;
+    readonly retryConfig: {
+        enabled: boolean;
+        maxRetries: number;
+    };
+    /** Timeout par défaut (ms) des requêtes JSON sans signal. `undefined` → défaut core (30s). */
+    readonly requestTimeoutMs?: number;
+    /** Hook d'observabilité (LOT 3) — voir `AuraClientOptions.onEvent`. */
+    readonly onEvent?: (event: AuraObservabilityEvent) => void;
+    /** Journalise chaque `AuraObservabilityEvent` via `console.debug` — voir `AuraClientOptions.debug`. */
+    readonly debug?: boolean;
+    private _auth;
+    private _db;
+    private _storage;
+    private _realtime;
+    private _functions;
+    private _ai;
+    private _notifications;
+    private _authAdmin;
+    private _disposed;
+    private readonly _persistSession;
+    private readonly _autoRefresh;
+    private readonly _detectSessionInUrl;
+    constructor(baseUrl: string, projectId: string, apiKeyOrOptions?: string | AuraClientOptions, options?: AuraClientOptions);
+    /**
+     * Démonte le client : arrête le refresh proactif (ticker + visibilité + BroadcastChannel),
+     * déconnecte le realtime, vide les listeners d'auth. Idempotent. À appeler en teardown
+     * (React Strict Mode / HMR / tests).
+     */
+    dispose(): void;
+    get auth(): AuthService;
+    get authAdmin(): AuthAdminService;
+    get db(): DatabaseService<Database>;
+    get storage(): StorageService;
+    get realtime(): RealtimeService;
+    get functions(): FunctionsService;
+    get ai(): AiService;
+    get notifications(): NotificationsService;
+    /**
+     * Shortcut: create a realtime channel with Supabase-compatible API.
+     * Equivalent to `aura.realtime.channel(name)`.
+     *
+     * @example
+     * ```ts
+     * const channel = aura.channel('room-1')
+     *   .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'messages' }, cb)
+     *   .subscribe()
+     * ```
+     */
+    channel(name: string, options?: ChannelConfig): AuraChannel;
+}
+
+export { AuraClient as A };

package/packages/aurabase/dist/AuraClient-DAtDbfPB.d.ts

@@ -0,0 +1,77 @@
+import { AuraClientLike, BaseAuthStore, AuraObservabilityEvent, AuraClientOptions, ChannelConfig } from '@aurabase/core';
+import { AuthService, AuthAdminService } from '@aurabase/auth';
+import { DatabaseService } from '@aurabase/db';
+import { StorageService } from '@aurabase/storage';
+import { RealtimeService, AuraChannel } from '@aurabase/realtime';
+import { FunctionsService } from '@aurabase/functions';
+import { AiService } from '@aurabase/ai';
+import { NotificationsService } from '@aurabase/notifications';
+
+/**
+ * Main Aurabase client.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'aurabase'
+ * const aura = createClient('http://localhost:8080', 'my-project-id')
+ * const { data } = await aura.db.from('posts').eq('published', true)
+ * ```
+ */
+declare class AuraClient<Database = any> implements AuraClientLike {
+    readonly baseUrl: string;
+    readonly projectId: string;
+    readonly apiKey: string | null;
+    readonly fetchFn: typeof globalThis.fetch;
+    readonly authStore: BaseAuthStore;
+    readonly retryConfig: {
+        enabled: boolean;
+        maxRetries: number;
+    };
+    /** Timeout par défaut (ms) des requêtes JSON sans signal. `undefined` → défaut core (30s). */
+    readonly requestTimeoutMs?: number;
+    /** Hook d'observabilité (LOT 3) — voir `AuraClientOptions.onEvent`. */
+    readonly onEvent?: (event: AuraObservabilityEvent) => void;
+    /** Journalise chaque `AuraObservabilityEvent` via `console.debug` — voir `AuraClientOptions.debug`. */
+    readonly debug?: boolean;
+    private _auth;
+    private _db;
+    private _storage;
+    private _realtime;
+    private _functions;
+    private _ai;
+    private _notifications;
+    private _authAdmin;
+    private _disposed;
+    private readonly _persistSession;
+    private readonly _autoRefresh;
+    private readonly _detectSessionInUrl;
+    constructor(baseUrl: string, projectId: string, apiKeyOrOptions?: string | AuraClientOptions, options?: AuraClientOptions);
+    /**
+     * Démonte le client : arrête le refresh proactif (ticker + visibilité + BroadcastChannel),
+     * déconnecte le realtime, vide les listeners d'auth. Idempotent. À appeler en teardown
+     * (React Strict Mode / HMR / tests).
+     */
+    dispose(): void;
+    get auth(): AuthService;
+    get authAdmin(): AuthAdminService;
+    get db(): DatabaseService<Database>;
+    get storage(): StorageService;
+    get realtime(): RealtimeService;
+    get functions(): FunctionsService;
+    get ai(): AiService;
+    get notifications(): NotificationsService;
+    /**
+     * Shortcut: create a realtime channel with Supabase-compatible API.
+     * Equivalent to `aura.realtime.channel(name)`.
+     *
+     * @example
+     * ```ts
+     * const channel = aura.channel('room-1')
+     *   .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'messages' }, cb)
+     *   .subscribe()
+     * ```
+     */
+    channel(name: string, options?: ChannelConfig): AuraChannel;
+}
+
+export { AuraClient as A };

package/packages/aurabase/dist/index.cjs

@@ -0,0 +1,237 @@
+'use strict';
+
+var core = require('@aurabase/core');
+var auth = require('@aurabase/auth');
+var db = require('@aurabase/db');
+var storage = require('@aurabase/storage');
+var realtime = require('@aurabase/realtime');
+var functions = require('@aurabase/functions');
+var ai = require('@aurabase/ai');
+var notifications = require('@aurabase/notifications');
+
+// src/AuraClient.ts
+function isBrowserContext() {
+  if (typeof window !== "undefined") return true;
+  const g = globalThis;
+  if (typeof g.DedicatedWorkerGlobalScope !== "undefined") return true;
+  if (typeof g.SharedWorkerGlobalScope !== "undefined") return true;
+  return false;
+}
+var SERVICE_ROLE_KEY_PREFIX = "aura_sk_";
+var AuraClient = class {
+  baseUrl;
+  projectId;
+  apiKey;
+  fetchFn;
+  authStore;
+  retryConfig;
+  /** Timeout par défaut (ms) des requêtes JSON sans signal. `undefined` → défaut core (30s). */
+  requestTimeoutMs;
+  /** Hook d'observabilité (LOT 3) — voir `AuraClientOptions.onEvent`. */
+  onEvent;
+  /** Journalise chaque `AuraObservabilityEvent` via `console.debug` — voir `AuraClientOptions.debug`. */
+  debug;
+  // Lazy-initialised service instances
+  _auth = null;
+  _db = null;
+  _storage = null;
+  _realtime = null;
+  _functions = null;
+  _ai = null;
+  _notifications = null;
+  _authAdmin = null;
+  _disposed = false;
+  _persistSession;
+  _autoRefresh;
+  _detectSessionInUrl;
+  constructor(baseUrl, projectId, apiKeyOrOptions, options) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.projectId = projectId;
+    const resolvedOptions = typeof apiKeyOrOptions === "string" ? options : apiKeyOrOptions;
+    this.apiKey = typeof apiKeyOrOptions === "string" ? apiKeyOrOptions : apiKeyOrOptions?.apiKey ?? null;
+    this.fetchFn = resolvedOptions?.fetch ?? globalThis.fetch.bind(globalThis);
+    const r = resolvedOptions?.retry;
+    this.retryConfig = r === false ? { enabled: false, maxRetries: 0 } : r === void 0 || r === true ? { enabled: true, maxRetries: core.DEFAULT_MAX_RETRIES } : { enabled: r.enabled ?? true, maxRetries: r.maxRetries ?? core.DEFAULT_MAX_RETRIES };
+    this.requestTimeoutMs = resolvedOptions?.requestTimeoutMs;
+    this.onEvent = resolvedOptions?.onEvent;
+    this.debug = resolvedOptions?.debug;
+    if (!this.apiKey && typeof console !== "undefined") {
+      console.warn(
+        "[aurabase] No API key provided. Most operations require an API key (apikey header). Only public auth routes (register, login, refresh) will work without one."
+      );
+    }
+    if (this.apiKey?.startsWith(SERVICE_ROLE_KEY_PREFIX) && isBrowserContext()) {
+      const refuse = resolvedOptions?.refuseServiceRoleInBrowser ?? true;
+      const message = "[aurabase] S\xC9CURIT\xC9 : une cl\xE9 service_role (aura_sk_\u2026) est fournie \xE0 createClient() dans un contexte navigateur. Cette cl\xE9 \xE0 privil\xE8ges \xE9lev\xE9s NE DOIT JAMAIS \xEAtre expos\xE9e c\xF4t\xE9 client (elle fuiterait dans le bundle). Utilisez une cl\xE9 anon (aura_anon_\u2026) c\xF4t\xE9 client, et createAdminClient() c\xF4t\xE9 serveur pour les op\xE9rations d'administration.";
+      if (refuse) {
+        throw new Error(message);
+      } else if (typeof console !== "undefined") {
+        console.warn(message);
+      }
+    }
+    if (resolvedOptions?.auth?.storage) {
+      this.authStore = resolvedOptions.auth.storage;
+    } else if (resolvedOptions?.auth?.persistSession === false) {
+      this.authStore = new core.BaseAuthStore();
+    } else if (typeof localStorage !== "undefined") {
+      this.authStore = new core.LocalAuthStore();
+    } else {
+      this.authStore = new core.BaseAuthStore();
+    }
+    this.authStore.setObservabilityHook(this.onEvent, this.debug);
+    this._persistSession = resolvedOptions?.auth?.persistSession !== false;
+    this._autoRefresh = resolvedOptions?.auth?.autoRefresh ?? true;
+    this._detectSessionInUrl = resolvedOptions?.auth?.detectSessionInUrl;
+    if (this._autoRefresh && this._persistSession && typeof window !== "undefined") {
+      void this.auth;
+    }
+  }
+  /**
+   * Démonte le client : arrête le refresh proactif (ticker + visibilité + BroadcastChannel),
+   * déconnecte le realtime, vide les listeners d'auth. Idempotent. À appeler en teardown
+   * (React Strict Mode / HMR / tests).
+   */
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this._auth?.dispose();
+    this._realtime?.disconnect();
+  }
+  // -- Lazy service getters ---------------------------------------------------
+  get auth() {
+    if (!this._auth) {
+      this._auth = new auth.AuthService(this, {
+        autoRefresh: this._autoRefresh,
+        persistSession: this._persistSession,
+        detectSessionInUrl: this._detectSessionInUrl
+      });
+    }
+    return this._auth;
+  }
+  get authAdmin() {
+    if (isBrowserContext()) {
+      throw new Error(
+        "[aurabase] S\xC9CURIT\xC9 : authAdmin est inaccessible dans un contexte navigateur. L'API admin requiert une cl\xE9 service_role qui ne doit JAMAIS \xEAtre expos\xE9e c\xF4t\xE9 client (elle fuiterait dans le bundle). Utilisez createAdminClient() c\xF4t\xE9 serveur uniquement."
+      );
+    }
+    if (!this._authAdmin) this._authAdmin = new auth.AuthAdminService(this);
+    return this._authAdmin;
+  }
+  get db() {
+    if (!this._db) this._db = new db.DatabaseService(this);
+    return this._db;
+  }
+  get storage() {
+    if (!this._storage) this._storage = new storage.StorageService(this);
+    return this._storage;
+  }
+  get realtime() {
+    if (!this._realtime) this._realtime = new realtime.RealtimeService(this);
+    return this._realtime;
+  }
+  get functions() {
+    if (!this._functions) this._functions = new functions.FunctionsService(this);
+    return this._functions;
+  }
+  get ai() {
+    if (!this._ai) this._ai = new ai.AiService(this);
+    return this._ai;
+  }
+  get notifications() {
+    if (!this._notifications) this._notifications = new notifications.NotificationsService(this);
+    return this._notifications;
+  }
+  /**
+   * Shortcut: create a realtime channel with Supabase-compatible API.
+   * Equivalent to `aura.realtime.channel(name)`.
+   *
+   * @example
+   * ```ts
+   * const channel = aura.channel('room-1')
+   *   .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'messages' }, cb)
+   *   .subscribe()
+   * ```
+   */
+  channel(name, options) {
+    return this.realtime.channel(name, options);
+  }
+};
+function createClient(baseUrl, projectId, apiKeyOrOptions, options) {
+  return new AuraClient(baseUrl, projectId, apiKeyOrOptions, options);
+}
+function createAdminClient(baseUrl, projectId, serviceRoleKey, options) {
+  if (isBrowserContext()) {
+    throw new Error(
+      "[aurabase] createAdminClient() ne doit jamais \xEAtre appel\xE9 c\xF4t\xE9 navigateur : la cl\xE9 service_role serait expos\xE9e dans le bundle. \xC0 utiliser uniquement c\xF4t\xE9 serveur."
+    );
+  }
+  return new AuraClient(baseUrl, projectId, serviceRoleKey, options);
+}
+
+Object.defineProperty(exports, "AuraError", {
+  enumerable: true,
+  get: function () { return core.AuraError; }
+});
+Object.defineProperty(exports, "BaseAuthStore", {
+  enumerable: true,
+  get: function () { return core.BaseAuthStore; }
+});
+Object.defineProperty(exports, "LocalAuthStore", {
+  enumerable: true,
+  get: function () { return core.LocalAuthStore; }
+});
+Object.defineProperty(exports, "isAuraError", {
+  enumerable: true,
+  get: function () { return core.isAuraError; }
+});
+Object.defineProperty(exports, "AuthAdminService", {
+  enumerable: true,
+  get: function () { return auth.AuthAdminService; }
+});
+Object.defineProperty(exports, "AuthService", {
+  enumerable: true,
+  get: function () { return auth.AuthService; }
+});
+Object.defineProperty(exports, "isMfaChallenge", {
+  enumerable: true,
+  get: function () { return auth.isMfaChallenge; }
+});
+Object.defineProperty(exports, "DatabaseService", {
+  enumerable: true,
+  get: function () { return db.DatabaseService; }
+});
+Object.defineProperty(exports, "QueryBuilder", {
+  enumerable: true,
+  get: function () { return db.QueryBuilder; }
+});
+Object.defineProperty(exports, "StorageService", {
+  enumerable: true,
+  get: function () { return storage.StorageService; }
+});
+Object.defineProperty(exports, "AuraChannel", {
+  enumerable: true,
+  get: function () { return realtime.AuraChannel; }
+});
+Object.defineProperty(exports, "RealtimeService", {
+  enumerable: true,
+  get: function () { return realtime.RealtimeService; }
+});
+Object.defineProperty(exports, "FunctionsService", {
+  enumerable: true,
+  get: function () { return functions.FunctionsService; }
+});
+Object.defineProperty(exports, "AiService", {
+  enumerable: true,
+  get: function () { return ai.AiService; }
+});
+Object.defineProperty(exports, "NotificationsAdminService", {
+  enumerable: true,
+  get: function () { return notifications.NotificationsAdminService; }
+});
+Object.defineProperty(exports, "NotificationsService", {
+  enumerable: true,
+  get: function () { return notifications.NotificationsService; }
+});
+exports.AuraClient = AuraClient;
+exports.createAdminClient = createAdminClient;
+exports.createClient = createClient;

package/packages/aurabase/dist/index.d.cts

@@ -0,0 +1,46 @@
+import { A as AuraClient } from './AuraClient-DAtDbfPB.cjs';
+import { AuraClientOptions } from '@aurabase/core';
+export { AdminCreateUserRequest, AdminUpdateUserRequest, AdminUser, AuditLogEntry, AuraClientOptions, AuraError, AuraErrorCode, AuraObservabilityEvent, AuraResponse, AuthChangePayload, AuthEvent, AuthSettings, BaseAuthStore, BatchSendResponse, BroadcastFilter, BroadcastPayload, ChannelConfig, ChatMessage, ChatResponse, CountMode, CronJob, EmailTemplateUpdate, EmbedRequest, EmbedResponse, FileEntry, FilterOp, FunctionDef, IdentityInfo, Job, LocalAuthStore, LoginResponse, MagicLinkRequest, Meta, MfaChallenge, MfaEnrollResponse, MfaVerifyRequest, Notification, NotificationAttempt, NotificationDeadLetter, NotificationEvent, NotificationProviderLog, NotificationQueueStats, NotificationRule, NotificationSettings, NotificationStats, NotificationTemplate, NotificationTemplatePreview, OAuthSignInOptions, PasswordResetRequest, PostgresChangesFilter, PresenceFilter, PresenceInfo, PresenceState, QueryFilter, QueryOptions, RagIngestRequest, RagIngestResponse, RagRequest, RagResponse, RealtimeEvent, RealtimeListenType, RealtimeSubscribeStatus, SchemaColumn, SchemaTable, SemanticSearchResult, SendNotificationRequest, SessionInfo, SignInRequest, SignUpRequest, StorageBucket, TokenPair, UpdateUserRequest, UploadResult, User, isAuraError } from '@aurabase/core';
+export { DatabaseService, QueryBuilder } from '@aurabase/db';
+export { AuthAdminService, AuthService, isMfaChallenge } from '@aurabase/auth';
+export { StorageService } from '@aurabase/storage';
+export { AuraChannel, RealtimeService } from '@aurabase/realtime';
+export { FunctionsService } from '@aurabase/functions';
+export { AiService } from '@aurabase/ai';
+export { NotificationsAdminService, NotificationsService } from '@aurabase/notifications';
+
+/**
+ * Create a new Aurabase client instance.
+ *
+ * @example
+ * ```ts
+ * // With API key (recommended — like Supabase)
+ * const aura = createClient('http://localhost:8080', 'project-uuid', 'aura_anon_xxx')
+ *
+ * // With options
+ * const aura = createClient('http://localhost:8080', 'project-uuid', 'aura_anon_xxx', {
+ *   auth: { persistSession: true }
+ * })
+ *
+ * // Without API key (backward compatible)
+ * const aura = createClient('http://localhost:8080', 'project-uuid')
+ * ```
+ */
+declare function createClient<Database = any>(baseUrl: string, projectId: string, apiKeyOrOptions?: string | AuraClientOptions, options?: AuraClientOptions): AuraClient<Database>;
+/**
+ * Crée un client à usage **SERVEUR uniquement** pour les opérations d'administration
+ * (`client.authAdmin` : lister/créer/bannir des utilisateurs, lire l'audit). Exige une
+ * clé `service_role`. Lève une erreur si appelé dans un navigateur — cette clé ne doit
+ * jamais être embarquée dans un bundle client (E21). Équivalent du séparateur
+ * Admin SDK de Firebase / `service_role` server-side de Supabase.
+ *
+ * @example
+ * ```ts
+ * // server-side only (API route, edge function, backend)
+ * const admin = createAdminClient(url, projectId, process.env.SERVICE_ROLE_KEY!)
+ * await admin.authAdmin.listUsers()
+ * ```
+ */
+declare function createAdminClient<Database = any>(baseUrl: string, projectId: string, serviceRoleKey: string, options?: AuraClientOptions): AuraClient<Database>;
+
+export { AuraClient, createAdminClient, createClient };

package/packages/aurabase/dist/index.d.ts

@@ -0,0 +1,46 @@
+import { A as AuraClient } from './AuraClient-DAtDbfPB.js';
+import { AuraClientOptions } from '@aurabase/core';
+export { AdminCreateUserRequest, AdminUpdateUserRequest, AdminUser, AuditLogEntry, AuraClientOptions, AuraError, AuraErrorCode, AuraObservabilityEvent, AuraResponse, AuthChangePayload, AuthEvent, AuthSettings, BaseAuthStore, BatchSendResponse, BroadcastFilter, BroadcastPayload, ChannelConfig, ChatMessage, ChatResponse, CountMode, CronJob, EmailTemplateUpdate, EmbedRequest, EmbedResponse, FileEntry, FilterOp, FunctionDef, IdentityInfo, Job, LocalAuthStore, LoginResponse, MagicLinkRequest, Meta, MfaChallenge, MfaEnrollResponse, MfaVerifyRequest, Notification, NotificationAttempt, NotificationDeadLetter, NotificationEvent, NotificationProviderLog, NotificationQueueStats, NotificationRule, NotificationSettings, NotificationStats, NotificationTemplate, NotificationTemplatePreview, OAuthSignInOptions, PasswordResetRequest, PostgresChangesFilter, PresenceFilter, PresenceInfo, PresenceState, QueryFilter, QueryOptions, RagIngestRequest, RagIngestResponse, RagRequest, RagResponse, RealtimeEvent, RealtimeListenType, RealtimeSubscribeStatus, SchemaColumn, SchemaTable, SemanticSearchResult, SendNotificationRequest, SessionInfo, SignInRequest, SignUpRequest, StorageBucket, TokenPair, UpdateUserRequest, UploadResult, User, isAuraError } from '@aurabase/core';
+export { DatabaseService, QueryBuilder } from '@aurabase/db';
+export { AuthAdminService, AuthService, isMfaChallenge } from '@aurabase/auth';
+export { StorageService } from '@aurabase/storage';
+export { AuraChannel, RealtimeService } from '@aurabase/realtime';
+export { FunctionsService } from '@aurabase/functions';
+export { AiService } from '@aurabase/ai';
+export { NotificationsAdminService, NotificationsService } from '@aurabase/notifications';
+
+/**
+ * Create a new Aurabase client instance.
+ *
+ * @example
+ * ```ts
+ * // With API key (recommended — like Supabase)
+ * const aura = createClient('http://localhost:8080', 'project-uuid', 'aura_anon_xxx')
+ *
+ * // With options
+ * const aura = createClient('http://localhost:8080', 'project-uuid', 'aura_anon_xxx', {
+ *   auth: { persistSession: true }
+ * })
+ *
+ * // Without API key (backward compatible)
+ * const aura = createClient('http://localhost:8080', 'project-uuid')
+ * ```
+ */
+declare function createClient<Database = any>(baseUrl: string, projectId: string, apiKeyOrOptions?: string | AuraClientOptions, options?: AuraClientOptions): AuraClient<Database>;
+/**
+ * Crée un client à usage **SERVEUR uniquement** pour les opérations d'administration
+ * (`client.authAdmin` : lister/créer/bannir des utilisateurs, lire l'audit). Exige une
+ * clé `service_role`. Lève une erreur si appelé dans un navigateur — cette clé ne doit
+ * jamais être embarquée dans un bundle client (E21). Équivalent du séparateur
+ * Admin SDK de Firebase / `service_role` server-side de Supabase.
+ *
+ * @example
+ * ```ts
+ * // server-side only (API route, edge function, backend)
+ * const admin = createAdminClient(url, projectId, process.env.SERVICE_ROLE_KEY!)
+ * await admin.authAdmin.listUsers()
+ * ```
+ */
+declare function createAdminClient<Database = any>(baseUrl: string, projectId: string, serviceRoleKey: string, options?: AuraClientOptions): AuraClient<Database>;
+
+export { AuraClient, createAdminClient, createClient };