@massalabs/gossip-sdk 0.0.2-dev.20260220143015 → 0.0.2-dev.20260223101931

package/README.md

@@ -33,6 +33,11 @@ await sdk.init();
 // 2. Open session (login)
 await sdk.openSession({
   mnemonic: 'word1 word2 word3 ... word12',
+  // Optional: for existing session
+  // encryptedSession: savedBlob,
+  // encryptionKey,  // optional - derived from mnemonic if not provided
+  // Optional: for persistence
+  // onPersist: async (blob, key) => { await saveToStorage(blob, key); },
 });
 
 // 3. Use the SDK
@@ -308,12 +313,12 @@ await sdk.init({
 
 ## Session Persistence
 
-For restoring sessions across app restarts:
+For restoring sessions across app restarts, pass `encryptionKey` (optional — derived from mnemonic if omitted) and `onPersist` when opening the session:
 
 ```typescript
 await sdk.openSession({
   mnemonic,
-  encryptionKey,
+  encryptionKey, // optional
   onPersist: async (blob, key) => {
     await storage.save({ session: blob });
   },
@@ -345,6 +350,26 @@ import type {
 import { SessionStatus, SdkEventType } from '@massalabs/gossip-sdk';
 ```
 
+## Database
+
+SQLite via [wa-sqlite](https://github.com/nicolo-ribaudo/wa-sqlite) (WASM) with [Drizzle ORM](https://orm.drizzle.team). Data is persisted to IndexedDB using `IDBBatchAtomicVFS`.
+
+### Schema
+
+Schema is defined in `src/db/schema/` with one file per table. Drizzle-kit generates SQL migrations from the schema.
+
+### Migrations
+
+Migrations live in `drizzle/` and are applied automatically on `initDb()` via Drizzle's built-in migrator.
+
+When you change the schema, regenerate migrations:
+
+```bash
+npm run db:generate
+```
+
+This runs `drizzle-kit generate`, which diffs the schema against existing migrations and outputs a new `.sql` file in `drizzle/`. Commit the generated migration alongside your schema change.
+
 ## Testing
 
 ```bash
@@ -358,10 +383,14 @@ Tests use wa-sqlite with in-memory databases for fast, isolated execution.
 
 ```
 gossip-sdk/
+├── drizzle/              # Generated SQL migrations
 ├── src/
 │   ├── gossipSdk.ts      # SDK class & factory
-│   ├── db.ts             # Database (SQLite) implementation
-│   ├── contacts.ts       # Contact operations
+│   ├── db/
+│   │   ├── index.ts      # Barrel export (all DB access goes through here)
+│   │   ├── schema/       # Drizzle table definitions (one file per table)
+│   │   ├── queries/      # Query functions
+│   │   └── sqlite.ts     # SQLite init, migration, connection
 │   ├── api/
 │   │   └── messageProtocol/  # REST protocol implementation
 │   ├── config/
@@ -376,7 +405,6 @@ gossip-sdk/
 │   │   ├── discussion.ts # Discussion service
 │   │   ├── announcement.ts # Announcement service
 │   │   └── refresh.ts    # Session refresh service
-│   ├── types/            # Type definitions
 │   ├── utils/            # Utility modules
 │   └── wasm/             # WASM module wrappers
 └── test/                 # Test files

package/dist/core/SdkEventEmitter.d.ts

@@ -13,6 +13,7 @@ export declare enum SdkEventType {
     SESSION_CREATED = "sessionCreated",
     SESSION_RENEWED = "sessionRenewed",
     SESSION_ACCEPTED = "sessionAccepted",
+    SEEKERS_UPDATED = "seekersUpdated",
     ERROR = "error"
 }
 export interface SdkEventHandlers {
@@ -24,6 +25,7 @@ export interface SdkEventHandlers {
     [SdkEventType.SESSION_CREATED]: (discussion: Discussion) => void;
     [SdkEventType.SESSION_RENEWED]: (discussion: Discussion) => void;
     [SdkEventType.SESSION_ACCEPTED]: (contactUserId: string) => void;
+    [SdkEventType.SEEKERS_UPDATED]: (seekers: Uint8Array[]) => void;
     [SdkEventType.ERROR]: (error: Error, context: string) => void;
 }
 export declare class SdkEventEmitter {

package/dist/core/SdkEventEmitter.js

@@ -16,6 +16,7 @@ export var SdkEventType;
     SdkEventType["SESSION_CREATED"] = "sessionCreated";
     SdkEventType["SESSION_RENEWED"] = "sessionRenewed";
     SdkEventType["SESSION_ACCEPTED"] = "sessionAccepted";
+    SdkEventType["SEEKERS_UPDATED"] = "seekersUpdated";
     SdkEventType["ERROR"] = "error";
 })(SdkEventType || (SdkEventType = {}));
 // ─────────────────────────────────────────────────────────────────────────────
@@ -36,6 +37,7 @@ export class SdkEventEmitter {
                 [SdkEventType.SESSION_CREATED]: new Set(),
                 [SdkEventType.SESSION_RENEWED]: new Set(),
                 [SdkEventType.SESSION_ACCEPTED]: new Set(),
+                [SdkEventType.SEEKERS_UPDATED]: new Set(),
                 [SdkEventType.ERROR]: new Set(),
             }
         });

package/dist/{db.d.ts → db/db.d.ts}

@@ -106,11 +106,21 @@ export interface ReadyAnnouncement {
 export type SendAnnouncement = null | ReadyAnnouncement;
 /** Serialize a SendAnnouncement to a JSON string for SQLite text column */
 export declare function serializeSendAnnouncement(announcement: ReadyAnnouncement): string;
-/** Deserialize a SendAnnouncement JSON string from SQLite back to an object */
+/** Deserialize a SendAnnouncement JSON string from SQLite back to an object.
+ *  Throws a descriptive error if the stored JSON is malformed. */
 export declare function deserializeSendAnnouncement(json: string): ReadyAnnouncement;
-/** Convert a raw SQLite discussion row to a Discussion object.
+/**
+ * Shape required by rowToDiscussion — matches Drizzle's inferred DiscussionRow
+ * without importing from schema (avoids circular dependency).
+ */
+interface DiscussionRowLike {
+    sendAnnouncement: string | null;
+    announcementMessage: string | null;
+    [key: string]: unknown;
+}
+/** Convert a Drizzle discussion row to a domain Discussion object.
  *  Deserializes sendAnnouncement from JSON text to SendAnnouncement. */
-export declare function rowToDiscussion(row: Record<string, unknown>): Discussion;
+export declare function rowToDiscussion(row: DiscussionRowLike): Discussion;
 export interface Discussion {
     id?: number;
     ownerUserId: string;
@@ -148,3 +158,4 @@ export interface ActiveSeeker {
     id?: number;
     seeker: Uint8Array;
 }
+export {};

package/dist/{db.js → db/db.js}

@@ -53,20 +53,29 @@ export function serializeSendAnnouncement(announcement) {
         when_to_send: announcement.when_to_send.toISOString(),
     });
 }
-/** Deserialize a SendAnnouncement JSON string from SQLite back to an object */
+/** Deserialize a SendAnnouncement JSON string from SQLite back to an object.
+ *  Throws a descriptive error if the stored JSON is malformed. */
 export function deserializeSendAnnouncement(json) {
-    const parsed = JSON.parse(json);
-    return {
-        announcement_bytes: new Uint8Array(parsed.announcement_bytes),
-        when_to_send: new Date(parsed.when_to_send),
-    };
+    try {
+        const parsed = JSON.parse(json);
+        if (!parsed || !parsed.announcement_bytes || !parsed.when_to_send) {
+            throw new Error('missing required fields');
+        }
+        return {
+            announcement_bytes: new Uint8Array(parsed.announcement_bytes),
+            when_to_send: new Date(parsed.when_to_send),
+        };
+    }
+    catch (e) {
+        throw new Error(`Failed to deserialize SendAnnouncement: ${e instanceof Error ? e.message : e}`);
+    }
 }
-/** Convert a raw SQLite discussion row to a Discussion object.
+/** Convert a Drizzle discussion row to a domain Discussion object.
  *  Deserializes sendAnnouncement from JSON text to SendAnnouncement. */
 export function rowToDiscussion(row) {
     return {
         ...row,
-        sendAnnouncement: typeof row.sendAnnouncement === 'string'
+        sendAnnouncement: row.sendAnnouncement !== null
             ? deserializeSendAnnouncement(row.sendAnnouncement)
             : null,
         lastAnnouncementMessage: row.announcementMessage ?? undefined,

package/dist/db/exec-utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared SQLite execution utilities.
+ *
+ * Used by both sqlite.ts (in-process path) and sqlite-worker.ts (Worker path)
+ * to avoid duplicating the wa-sqlite prepare/bind/step/finalize logic.
+ */
+import * as SQLite from 'wa-sqlite';
+export type SqliteAPI = ReturnType<typeof SQLite.Factory>;
+/**
+ * Copy blob values out of WASM linear memory.
+ * wa-sqlite's column_blob() returns a Uint8Array VIEW into Module.HEAPU8.
+ * These views become stale after finalize() or memory growth.
+ */
+export declare function copyRow(row: unknown[]): unknown[];
+/**
+ * Execute a SQL statement against a wa-sqlite database handle.
+ * Handles both parameterless (exec) and parameterized (prepare_v2) paths.
+ */
+export declare function execStatements(sqlite3: SqliteAPI, dbHandle: number, sql: string, params?: unknown[]): Promise<unknown[][]>;

package/dist/db/exec-utils.js

@@ -0,0 +1,48 @@
+/**
+ * Shared SQLite execution utilities.
+ *
+ * Used by both sqlite.ts (in-process path) and sqlite-worker.ts (Worker path)
+ * to avoid duplicating the wa-sqlite prepare/bind/step/finalize logic.
+ */
+import * as SQLite from 'wa-sqlite';
+/**
+ * Copy blob values out of WASM linear memory.
+ * wa-sqlite's column_blob() returns a Uint8Array VIEW into Module.HEAPU8.
+ * These views become stale after finalize() or memory growth.
+ */
+export function copyRow(row) {
+    return row.map(v => (v instanceof Uint8Array ? new Uint8Array(v) : v));
+}
+/**
+ * Execute a SQL statement against a wa-sqlite database handle.
+ * Handles both parameterless (exec) and parameterized (prepare_v2) paths.
+ */
+export async function execStatements(sqlite3, dbHandle, sql, params = []) {
+    if (params.length === 0) {
+        const rows = [];
+        await sqlite3.exec(dbHandle, sql, (row) => {
+            rows.push(copyRow(row));
+        });
+        return rows;
+    }
+    const str = sqlite3.str_new(dbHandle, sql);
+    try {
+        const prepared = await sqlite3.prepare_v2(dbHandle, sqlite3.str_value(str));
+        if (!prepared)
+            return [];
+        try {
+            sqlite3.bind_collection(prepared.stmt, params);
+            const rows = [];
+            while ((await sqlite3.step(prepared.stmt)) === SQLite.SQLITE_ROW) {
+                rows.push(copyRow(sqlite3.row(prepared.stmt)));
+            }
+            return rows;
+        }
+        finally {
+            await sqlite3.finalize(prepared.stmt);
+        }
+    }
+    finally {
+        sqlite3.str_finish(str);
+    }
+}

package/dist/db/generated-ddl.d.ts

@@ -0,0 +1 @@
+export declare const DDL: string[];

package/dist/db/generated-ddl.js

@@ -0,0 +1,31 @@
+// Auto-generated from drizzle migrations — do not edit manually.
+// Regenerate with: npm run db:generate
+export const DDL = [
+    'CREATE TABLE IF NOT EXISTS `activeSeekers` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`seeker` blob NOT NULL\n);',
+    'CREATE INDEX IF NOT EXISTS `active_seekers_seeker_idx` ON `activeSeekers` (`seeker`);',
+    'CREATE TABLE IF NOT EXISTS `announcementCursors` (\n\t`userId` text PRIMARY KEY NOT NULL,\n\t`counter` text NOT NULL\n);',
+    'CREATE TABLE IF NOT EXISTS `contacts` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`ownerUserId` text NOT NULL,\n\t`userId` text NOT NULL,\n\t`name` text NOT NULL,\n\t`avatar` text,\n\t`publicKeys` blob NOT NULL,\n\t`isOnline` integer NOT NULL,\n\t`lastSeen` integer NOT NULL,\n\t`createdAt` integer NOT NULL\n);',
+    'CREATE INDEX IF NOT EXISTS `contacts_owner_user_idx` ON `contacts` (`ownerUserId`,`userId`);',
+    'CREATE INDEX IF NOT EXISTS `contacts_owner_name_idx` ON `contacts` (`ownerUserId`,`name`);',
+    'CREATE TABLE IF NOT EXISTS `discussions` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`ownerUserId` text NOT NULL,\n\t`contactUserId` text NOT NULL,\n\t`weAccepted` integer DEFAULT false NOT NULL,\n\t`sendAnnouncement` text,\n\t`direction` text NOT NULL,\n\t`status` text NOT NULL,\n\t`nextSeeker` blob,\n\t`initiationAnnouncement` blob,\n\t`announcementMessage` text,\n\t`lastSyncTimestamp` integer,\n\t`customName` text,\n\t`lastMessageId` integer,\n\t`lastMessageContent` text,\n\t`lastMessageTimestamp` integer,\n\t`unreadCount` integer DEFAULT 0 NOT NULL,\n\t`createdAt` integer NOT NULL,\n\t`updatedAt` integer NOT NULL\n);',
+    'CREATE UNIQUE INDEX IF NOT EXISTS `discussions_owner_contact_idx` ON `discussions` (`ownerUserId`,`contactUserId`);',
+    'CREATE INDEX IF NOT EXISTS `discussions_owner_status_idx` ON `discussions` (`ownerUserId`,`status`);',
+    'CREATE TABLE IF NOT EXISTS `messages` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`ownerUserId` text NOT NULL,\n\t`contactUserId` text NOT NULL,\n\t`messageId` blob,\n\t`content` text NOT NULL,\n\t`serializedContent` blob,\n\t`type` text NOT NULL,\n\t`direction` text NOT NULL,\n\t`status` text NOT NULL,\n\t`timestamp` integer NOT NULL,\n\t`metadata` text,\n\t`seeker` blob,\n\t`replyTo` text,\n\t`forwardOf` text,\n\t`encryptedMessage` blob,\n\t`whenToSend` integer\n);',
+    'CREATE INDEX IF NOT EXISTS `messages_owner_contact_idx` ON `messages` (`ownerUserId`,`contactUserId`);',
+    'CREATE INDEX IF NOT EXISTS `messages_owner_status_idx` ON `messages` (`ownerUserId`,`status`);',
+    'CREATE INDEX IF NOT EXISTS `messages_owner_contact_status_idx` ON `messages` (`ownerUserId`,`contactUserId`,`status`);',
+    'CREATE INDEX IF NOT EXISTS `messages_owner_seeker_idx` ON `messages` (`ownerUserId`,`seeker`);',
+    'CREATE INDEX IF NOT EXISTS `messages_owner_contact_dir_idx` ON `messages` (`ownerUserId`,`contactUserId`,`direction`);',
+    'CREATE INDEX IF NOT EXISTS `messages_owner_dir_status_idx` ON `messages` (`ownerUserId`,`direction`,`status`);',
+    'CREATE INDEX IF NOT EXISTS `messages_timestamp_idx` ON `messages` (`timestamp`);',
+    'CREATE TABLE IF NOT EXISTS `pendingAnnouncements` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`announcement` blob NOT NULL,\n\t`fetchedAt` integer NOT NULL,\n\t`counter` text\n);',
+    'CREATE UNIQUE INDEX IF NOT EXISTS `pending_announcements_announcement_idx` ON `pendingAnnouncements` (`announcement`);',
+    'CREATE INDEX IF NOT EXISTS `pending_announcements_fetchedAt_idx` ON `pendingAnnouncements` (`fetchedAt`);',
+    'CREATE TABLE IF NOT EXISTS `pendingEncryptedMessages` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`seeker` blob NOT NULL,\n\t`ciphertext` blob NOT NULL,\n\t`fetchedAt` integer NOT NULL\n);',
+    'CREATE INDEX IF NOT EXISTS `pending_encrypted_seeker_idx` ON `pendingEncryptedMessages` (`seeker`);',
+    'CREATE INDEX IF NOT EXISTS `pending_encrypted_fetchedAt_idx` ON `pendingEncryptedMessages` (`fetchedAt`);',
+    'CREATE TABLE IF NOT EXISTS `userProfile` (\n\t`userId` text PRIMARY KEY NOT NULL,\n\t`username` text NOT NULL,\n\t`avatar` text,\n\t`bio` text,\n\t`status` text NOT NULL,\n\t`lastSeen` integer NOT NULL,\n\t`createdAt` integer NOT NULL,\n\t`updatedAt` integer NOT NULL,\n\t`lastPublicKeyPush` integer,\n\t`security` text NOT NULL,\n\t`session` blob NOT NULL\n);',
+    'CREATE INDEX IF NOT EXISTS `userProfile_username_idx` ON `userProfile` (`username`);',
+    'CREATE INDEX IF NOT EXISTS `userProfile_status_idx` ON `userProfile` (`status`);',
+    'CREATE INDEX IF NOT EXISTS `messages_owner_contact_msgid_idx` ON `messages` (`ownerUserId`,`contactUserId`,`messageId`);',
+];

package/dist/db/index.d.ts

@@ -0,0 +1,3 @@
+export * from './db';
+export * from './queries';
+export * from './sqlite';

package/dist/db/index.js

@@ -0,0 +1,3 @@
+export * from './db';
+export * from './queries';
+export * from './sqlite';

package/dist/db/queries/activeSeekers.d.ts

@@ -0,0 +1 @@
+export declare function replaceActiveSeekers(seekers: Uint8Array[]): Promise<void>;

package/dist/{queries → db/queries}/activeSeekers.js

@@ -1,9 +1,5 @@
 import * as schema from '../schema';
 import { getSqliteDb, withTransaction } from '../sqlite';
-let onSeekersUpdated = null;
-export function setOnSeekersUpdated(cb) {
-    onSeekersUpdated = cb;
-}
 export async function replaceActiveSeekers(seekers) {
     await withTransaction(async () => {
         const db = getSqliteDb();
@@ -14,5 +10,4 @@ export async function replaceActiveSeekers(seekers) {
                 .values(seekers.map(seeker => ({ seeker })));
         }
     });
-    onSeekersUpdated?.(seekers);
 }

package/dist/{queries → db/queries}/messages.d.ts

@@ -1,5 +1,5 @@
 import * as schema from '../schema';
-import { MessageStatus } from '../db';
+import { MessageStatus } from '../../db/db';
 export type MessageRow = typeof schema.messages.$inferSelect;
 export type MessageInsert = typeof schema.messages.$inferInsert;
 export declare function getMessageById(id: number): Promise<MessageRow | undefined>;
@@ -14,7 +14,7 @@ export declare function deleteDeliveredKeepAliveMessages(ownerUserId: string): P
 export declare function getOutgoingSentMessagesByOwner(ownerUserId: string): Promise<MessageRow[]>;
 export declare function getWaitingMessageCount(ownerUserId: string, contactUserId: string): Promise<number>;
 export declare function getSendQueueMessages(ownerUserId: string, contactUserId: string): Promise<MessageRow[]>;
-export declare function getMessagesByStatus(status: MessageStatus): Promise<MessageRow[]>;
+export declare function getMessagesByStatus(ownerUserId: string, status: MessageStatus): Promise<MessageRow[]>;
 /**
  * Reset outgoing messages to WAITING_SESSION, clearing encryption data.
  * @param statuses - If provided, only reset messages with these statuses.

package/dist/{queries → db/queries}/messages.js

@@ -1,7 +1,7 @@
 import { eq, and, sql, inArray, asc } from 'drizzle-orm';
 import * as schema from '../schema';
 import { getSqliteDb, getLastInsertRowId } from '../sqlite';
-import { MessageDirection, MessageStatus, MessageType } from '../db';
+import { MessageDirection, MessageStatus, MessageType } from '../../db/db';
 export async function getMessageById(id) {
     return getSqliteDb()
         .select()
@@ -82,11 +82,11 @@ export async function getSendQueueMessages(ownerUserId, contactUserId) {
         .orderBy(asc(schema.messages.timestamp), asc(schema.messages.id))
         .all();
 }
-export async function getMessagesByStatus(status) {
+export async function getMessagesByStatus(ownerUserId, status) {
     return getSqliteDb()
         .select()
         .from(schema.messages)
-        .where(eq(schema.messages.status, status))
+        .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.status, status)))
         .all();
 }
 /**

package/dist/{queries → db/queries}/userProfile.d.ts

@@ -6,7 +6,7 @@ export type UserProfileInsert = typeof schema.userProfile.$inferInsert;
 export declare function rowToUserProfile(row: UserProfileRow): UserProfile;
 /** Convert a domain UserProfile to a DB-ready insert row (security as JSON string). */
 export declare function userProfileToRow(profile: UserProfile): UserProfileInsert;
-export declare function getUserProfileField(userId: string): Promise<UserProfileRow | undefined>;
+export declare function getUserProfileById(userId: string): Promise<UserProfileRow | undefined>;
 export declare function updateUserProfileById(userId: string, data: Partial<UserProfileInsert>): Promise<void>;
 export declare function getUserProfileByUsernameLower(username: string): Promise<{
     userId: string;

package/dist/{queries → db/queries}/userProfile.js

@@ -51,7 +51,7 @@ export function userProfileToRow(profile) {
         lastPublicKeyPush: profile.lastPublicKeyPush ?? null,
     };
 }
-export async function getUserProfileField(userId) {
+export async function getUserProfileById(userId) {
     return getSqliteDb()
         .select()
         .from(schema.userProfile)

package/dist/db/schema/_helpers.d.ts

@@ -0,0 +1,26 @@
+export declare const bytes: {
+    (): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        name: "";
+        dataType: "custom";
+        columnType: "SQLiteCustomColumn";
+        data: Uint8Array<ArrayBufferLike>;
+        driverParam: Uint8Array<ArrayBufferLike>;
+        enumValues: undefined;
+    }>;
+    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        name: "";
+        dataType: "custom";
+        columnType: "SQLiteCustomColumn";
+        data: Uint8Array<ArrayBufferLike>;
+        driverParam: Uint8Array<ArrayBufferLike>;
+        enumValues: undefined;
+    }>;
+    <TName extends string>(dbName: TName, fieldConfig?: unknown): import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
+        name: TName;
+        dataType: "custom";
+        columnType: "SQLiteCustomColumn";
+        data: Uint8Array<ArrayBufferLike>;
+        driverParam: Uint8Array<ArrayBufferLike>;
+        enumValues: undefined;
+    }>;
+};

package/dist/db/schema/_helpers.js

@@ -0,0 +1,15 @@
+import { customType } from 'drizzle-orm/sqlite-core';
+// Custom blob type — wa-sqlite returns Uint8Array natively for BLOB columns.
+// Drizzle's built-in blob mode converts to/from hex strings, which breaks
+// with wa-sqlite's direct Uint8Array handling. This custom type passes through.
+export const bytes = customType({
+    dataType() {
+        return 'blob';
+    },
+    fromDriver(value) {
+        return value;
+    },
+    toDriver(value) {
+        return value;
+    },
+});

package/dist/db/schema/activeSeekers.d.ts

@@ -0,0 +1,43 @@
+export declare const activeSeekers: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "activeSeekers";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "activeSeekers";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        seeker: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "seeker";
+            tableName: "activeSeekers";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Uint8Array<ArrayBufferLike>;
+            driverParam: Uint8Array<ArrayBufferLike>;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/db/schema/activeSeekers.js

@@ -0,0 +1,6 @@
+import { sqliteTable, integer, index } from 'drizzle-orm/sqlite-core';
+import { bytes } from './_helpers';
+export const activeSeekers = sqliteTable('activeSeekers', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    seeker: bytes('seeker').notNull(),
+}, table => [index('active_seekers_seeker_idx').on(table.seeker)]);

package/dist/db/schema/announcementCursors.d.ts

@@ -0,0 +1,45 @@
+export declare const announcementCursors: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "announcementCursors";
+    schema: undefined;
+    columns: {
+        userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "userId";
+            tableName: "announcementCursors";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        counter: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "counter";
+            tableName: "announcementCursors";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/db/schema/announcementCursors.js

@@ -0,0 +1,5 @@
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+export const announcementCursors = sqliteTable('announcementCursors', {
+    userId: text('userId').primaryKey(),
+    counter: text('counter').notNull(),
+});