cry-synced-db-client 0.1.1

package/dist/types/CollectionConfig.d.ts

@@ -0,0 +1,7 @@
+import type { QuerySpec } from ".";
+export interface CollectionConfig<T> {
+    name: string;
+    query?: QuerySpec<T>;
+    indexes?: (keyof T)[];
+    resolveSyncConflict?(local: T, external: T): T;
+}

package/dist/types/DbEntity.d.ts

@@ -0,0 +1,30 @@
+import type { ObjectId, Timestamp } from "mongodb";
+export type Id = ObjectId | string | number;
+export type Entity = {
+    _id: Id;
+};
+export type IdOrEntity = ObjectId | string | number | Entity;
+/**
+ * Osnovni objekt v nekem collection (serverski tip)
+ * Vsebuje sistemska polja za sinhronizacijo
+ */
+export interface DbEntity {
+    _id: Id;
+    _rev?: number;
+    _ts?: Timestamp;
+    _csq?: number;
+    _deleted?: Date;
+    _blocked?: boolean;
+    /** ID zadnjega updaterja - za detekcijo loopback */
+    _lastUpdaterId?: string;
+}
+/**
+ * Razširitev DbEntity z lokalnimi polji za sync tracking
+ * Uporablja se v dexie bazi
+ */
+export interface LocalDbEntity extends DbEntity {
+    /** Označuje, da ima objekt lokalne spremembe, ki čakajo na sync */
+    _dirty?: boolean;
+    /** Čas zadnje lokalne spremembe */
+    _localChangedAt?: Date;
+}

package/dist/types/I_DexieDb.d.ts

@@ -0,0 +1,47 @@
+import type { Id, LocalDbEntity } from "./DbEntity";
+/**
+ * Metapodatki o sinhronizaciji za vsako kolekcijo
+ */
+export interface SyncMeta {
+    tenant: string;
+    collection: string;
+    lastSyncTs?: any;
+}
+/**
+ * Interface za Dexie (IndexedDB) bazo podatkov
+ * Vse metode so async ker IndexedDB je asinhrona
+ */
+export interface I_DexieDb {
+    /** Shrani/posodobi objekt v kolekciji */
+    save<T extends LocalDbEntity>(collection: string, id: Id, data: Partial<T>): Promise<void>;
+    /** Shrani/posodobi več objektov naenkrat (bulk upsert) */
+    saveMany<T extends LocalDbEntity>(collection: string, items: T[]): Promise<void>;
+    /** Vstavi nov objekt v kolekcijo */
+    insert<T extends LocalDbEntity>(collection: string, data: T): Promise<void>;
+    /** Izbriše objekt iz kolekcije */
+    deleteOne(collection: string, id: Id): Promise<void>;
+    /** Shrani celotno kolekcijo (nadomesti obstoječo) */
+    saveCollection<T extends LocalDbEntity>(collection: string, data: T[]): Promise<void>;
+    /** Izbriše celotno kolekcijo */
+    deleteCollection(collection: string): Promise<void>;
+    /** Vrne objekt po ID-ju */
+    getById<T extends LocalDbEntity>(collection: string, id: Id): Promise<T | undefined>;
+    /** Vrne vse objekte v kolekciji */
+    getAll<T extends LocalDbEntity>(collection: string): Promise<T[]>;
+    /** Vrne število objektov v kolekciji */
+    count(collection: string): Promise<number>;
+    /** Vrne vse dirty objekte (z lokalnimi spremembami) */
+    getDirty<T extends LocalDbEntity>(collection: string): Promise<T[]>;
+    /** Označi objekt kot umazan (ima lokalne spremembe) */
+    markDirty(collection: string, id: Id): Promise<void>;
+    /** Označi objekt kot čist (sinhroniziran s serverjem) */
+    markClean(collection: string, id: Id): Promise<void>;
+    /** Vrne sync metapodatke za kolekcijo */
+    getSyncMeta(collection: string): Promise<SyncMeta | undefined>;
+    /** Nastavi sync metapodatke za kolekcijo */
+    setSyncMeta(collection: string, lastSyncTs: any): Promise<void>;
+    /** Izbriše sync metapodatke za kolekcijo */
+    deleteSyncMeta(collection: string): Promise<void>;
+    /** Vrne tenant */
+    getTenant(): string;
+}

package/dist/types/I_InMemDb.d.ts

@@ -0,0 +1,25 @@
+import type { Id, DbEntity } from "./DbEntity";
+/**
+ * Interface za in-memory bazo podatkov
+ * UI samo bere iz te baze, posodablja jo samo sync-db
+ */
+export interface I_InMemDb {
+    /** Shrani/posodobi objekt v kolekciji */
+    save<T extends DbEntity>(collection: string, id: Id, data: Partial<T>): void;
+    /** Shrani/posodobi več objektov naenkrat (bulk upsert) */
+    saveMany<T extends DbEntity>(collection: string, items: T[]): void;
+    /** Vstavi nov objekt v kolekcijo */
+    insert<T extends DbEntity>(collection: string, data: T): void;
+    /** Izbriše objekt iz kolekcije */
+    deleteOne(collection: string, id: Id): void;
+    /** Shrani celotno kolekcijo (nadomesti obstoječo) */
+    saveCollection<T extends DbEntity>(collection: string, data: T[]): void;
+    /** Izbriše celotno kolekcijo */
+    deleteCollection(collection: string): void;
+    /** Vrne objekt po ID-ju */
+    getById<T extends DbEntity>(collection: string, id: Id): T | undefined;
+    /** Vrne vse objekte v kolekciji */
+    getAll<T extends DbEntity>(collection: string): T[];
+    /** Vrne število objektov v kolekciji */
+    count(collection: string): number;
+}

package/dist/types/I_RestInterface.d.ts

@@ -0,0 +1,54 @@
+import type { Timestamp, Document, SchemaMember, CollationOptions, ReadPreference, FindOneAndUpdateOptions, AggregateOptions } from "mongodb";
+import type { Id } from "./DbEntity";
+export type Obj = {
+    [key: string]: any;
+};
+export type QuerySpec<T> = Partial<Record<keyof T | "_deleted" | "_blocked" | "_ts" | "_id", any>>;
+export type Projection = SchemaMember<any, Document | number | boolean | any>;
+export type QueryOpts = Partial<{
+    project: Projection;
+    sort: Record<string, -1 | 1>;
+    limit: number;
+    skip: number;
+    collation: CollationOptions;
+    readPreference: ReadPreference;
+    /** Če je true, vrne tudi soft-deleted objekte (z _deleted poljem) */
+    returnDeleted: boolean;
+}>;
+export type KeyOf<T> = keyof T | "$bit" | "$set" | "$inc" | "$currentDate" | "$min" | "$max" | "$mul" | "$rename" | "$setOnInsert" | "$unset" | "$pull" | "$push" | "$pop" | "$addToSet" | "$pushAll" | "_rev" | "_ts" | "_csq" | "_deleted";
+export type InsertKeyOf<T> = keyof T | "_rev" | "_ts" | "_csq" | "_deleted";
+export type InsertSpec<T> = Partial<Record<InsertKeyOf<T>, any>>;
+export type UpdateSpec<T> = Partial<Record<KeyOf<T>, any>>;
+export type BatchSpec<T> = {
+    query: QuerySpec<T>;
+    update: UpdateSpec<T>;
+    opts?: UpsertOptions;
+}[];
+export interface UpsertOptions extends FindOneAndUpdateOptions {
+    returnFullObject?: boolean;
+}
+export interface GetNewerSpec<T> {
+    collection: string;
+    timestamp: number | Date | string | Timestamp;
+    query?: QuerySpec<T>;
+    opts?: QueryOpts;
+}
+/**
+ * Minimalni interface za komunikacijo s serverjem (cry-db Mongo)
+ * Vsebuje samo metode, potrebne za sinhronizacijo
+ */
+export interface I_RestInterface {
+    /** Preveri povezljivost s serverjem - vrne true če je server dosegljiv */
+    ping(): Promise<boolean>;
+    findNewer<T>(collection: string, timestamp: Timestamp | number | string | Date, query?: QuerySpec<T>, opts?: QueryOpts): Promise<T[]>;
+    findNewerMany<T>(spec?: GetNewerSpec<T>[]): Promise<Record<string, any[]>>;
+    latestTimestamp(collection: string): Promise<Timestamp | undefined>;
+    latestTimestamps(collections: string[]): Promise<Record<string, Timestamp>>;
+    save<T>(collection: string, update: UpdateSpec<T>, id?: Id): Promise<T>;
+    insert<T>(collection: string, insert: InsertSpec<T>): Promise<T>;
+    deleteOne<T>(collection: string, query: QuerySpec<T>): Promise<T>;
+    /** Izvede agregacijo na serverju */
+    aggregate<T>(collection: string, pipeline: object[], opts?: AggregateOptions): Promise<T[]>;
+    /** Izvede batch upsert na serverju - ne posodablja lokalne baze */
+    upsertBatch<T>(collection: string, batch: BatchSpec<T>): Promise<T[]>;
+}

package/dist/types/I_ServerUpdateNotifier.d.ts

@@ -0,0 +1,29 @@
+import type { PublishRevsPayload } from "./PublishRevsPayload";
+/**
+ * Callback za prejemanje server update notifikacij
+ */
+export type ServerUpdateCallback = (payload: PublishRevsPayload) => void;
+/**
+ * Interface za prejemanje notifikacij o spremembah na serverju
+ * Implementacija je odvisna od transporta (WebSocket, SSE, polling, etc.)
+ */
+export interface I_ServerUpdateNotifier {
+    /**
+     * Registriraj callback za prejemanje update notifikacij
+     * @param callback Funkcija, ki se pokliče ob vsaki notifikaciji
+     * @returns Funkcija za odstranitev callbacka (unsubscribe)
+     */
+    subscribe(callback: ServerUpdateCallback): () => void;
+    /**
+     * Začni poslušati za notifikacije
+     */
+    connect(): Promise<void>;
+    /**
+     * Prenehaj poslušati za notifikacije
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Ali je povezava aktivna
+     */
+    isConnected(): boolean;
+}

package/dist/types/I_SyncedDb.d.ts

@@ -0,0 +1,149 @@
+import type { AggregateOptions } from "mongodb";
+import type { Id, DbEntity } from "./DbEntity";
+import type { QuerySpec, UpdateSpec, InsertSpec, BatchSpec, I_RestInterface } from "./I_RestInterface";
+import type { I_DexieDb } from "./I_DexieDb";
+import type { I_InMemDb } from "./I_InMemDb";
+import type { I_ServerUpdateNotifier } from "./I_ServerUpdateNotifier";
+/**
+ * Informacije o sinhronizaciji za debugging/logging
+ */
+export interface SyncInfo {
+    /** Trajanje sinhronizacije v ms */
+    durationMs: number;
+    /** Število prejetih objektov s serverja */
+    receivedCount: number;
+    /** Število poslanih dirty objektov na server */
+    sentCount: number;
+    /** Število konfliktov, ki so bili razrešeni */
+    conflictsResolved: number;
+    /** Ali je sync uspel */
+    success: boolean;
+    /** Napaka, če sync ni uspel */
+    error?: Error;
+}
+/**
+ * Konfiguracija za posamezno kolekcijo
+ */
+export interface CollectionConfig {
+    /** Ime kolekcije */
+    name: string;
+    /** Opcijski filter za velike tabele - omeji obseg sinhronizacije */
+    query?: QuerySpec<any>;
+    /** Dodatni indexi poleg _id */
+    indexes?: string[];
+    /** Opcijska funkcija za razreševanje konfliktov */
+    resolveSyncConflict?<T extends DbEntity>(local: T, external: T): T;
+}
+/**
+ * Konfiguracija za SyncedDb - dependencies so podani kot parametri (DI)
+ */
+export interface SyncedDbConfig {
+    /** Identifikator tenanta */
+    tenant: string;
+    /** Seznam kolekcij za sinhronizacijo */
+    collections: CollectionConfig[];
+    /** Dexie (IndexedDB) baza - dependency injection */
+    dexieDb: I_DexieDb;
+    /** In-memory baza - dependency injection */
+    inMemDb: I_InMemDb;
+    /** REST interface za komunikacijo s serverjem - dependency injection */
+    restInterface: I_RestInterface;
+    /** Server update notifier - dependency injection (opcijsko) */
+    serverUpdateNotifier?: I_ServerUpdateNotifier;
+    /** Timeout za splošne REST klice v ms (default: 10000) */
+    restTimeoutMs?: number;
+    /** Timeout za sync REST klice v ms (default: 30000) - daljši ker sync prenaša več podatkov */
+    syncTimeoutMs?: number;
+    /** Debounce čas za zapis v Dexie v ms (default: 1000) */
+    debounceMs?: number;
+    /** Callback ki se pokliče, ko SyncedDb sam preide v offline stanje (npr. ob sync napaki) */
+    onForcedOffline?: (reason: string) => void;
+    /** Callback za debugging/logging - pokliče se po vsaki sinhronizaciji */
+    onSync?: (info: SyncInfo) => void;
+}
+/**
+ * Glavna logika za sinhronizirano bazo podatkov
+ *
+ * - Deluje offline-first, kjer so offline podatki v Dexie (IndexedDB)
+ * - Vzdržuje in-mem-db sinhroniziran z Dexie
+ * - Spremlja server updates in posodablja lokalno bazo
+ * - Ko preide v online stanje, sinhronizira s serverjem
+ */
+export interface I_SyncedDb {
+    /** Inicializira bazo in izvede začetno sinhronizacijo */
+    init(): Promise<void>;
+    /** Zapre bazo in počisti resurse */
+    close(): Promise<void>;
+    /** Ali je povezan na server */
+    isOnline(): boolean;
+    /** Nastavi online/offline status */
+    setOnline(online: boolean): void;
+    /** Poišče objekt po ID-ju */
+    findById<T extends DbEntity>(collection: string, id: Id): Promise<T | null>;
+    /** Poišče objekte po ID-jih */
+    findByIds<T extends DbEntity>(collection: string, ids: Id[]): Promise<T[]>;
+    /** Poišče prvi objekt, ki ustreza poizvedbi */
+    findOne<T extends DbEntity>(collection: string, query: QuerySpec<T>): Promise<T | null>;
+    /** Poišče vse objekte, ki ustrezajo poizvedbi */
+    find<T extends DbEntity>(collection: string, query?: QuerySpec<T>): Promise<T[]>;
+    /** Izvede agregacijo na serverju (offline vrne []) */
+    aggregate<T>(collection: string, pipeline: object[], opts?: AggregateOptions): Promise<T[]>;
+    /**
+     * Posodobi objekt - doda spremembe na objekt
+     * Če objekt ne obstaja, ga ustvari in izpiše warning
+     */
+    save<T extends DbEntity>(collection: string, id: Id, update: Partial<T>): Promise<T>;
+    /**
+     * Posodobi objekt po poizvedbi, če je treba ga ustvari
+     */
+    upsert<T extends DbEntity>(collection: string, query: QuerySpec<T>, update: UpdateSpec<T>): Promise<T>;
+    /**
+     * Vstavi nov objekt
+     * Če objekt že obstaja, ga prepiše in izpiše warning
+     */
+    insert<T extends DbEntity>(collection: string, data: InsertSpec<T>): Promise<T>;
+    /**
+     * Izbriše objekt (soft delete)
+     * - Nastavi _deleted = new Date()
+     * - Objekt izbriše iz in-mem-db
+     * - Pusti ga v dexie do sinhronizacije s serverjem
+     */
+    deleteOne<T extends DbEntity>(collection: string, id: Id): Promise<T | null>;
+    /**
+     * Izbriše več objektov po poizvedbi (soft delete)
+     */
+    deleteMany<T extends DbEntity>(collection: string, query: QuerySpec<T>): Promise<number>;
+    /**
+     * Trajno izbriše objekt po ID-ju
+     * - Deluje samo online, offline vrže napako
+     * - Izbriše iz serverja, dexie in in-mem
+     */
+    hardDeleteOne<T extends DbEntity>(collection: string, id: Id): Promise<T | null>;
+    /**
+     * Trajno izbriše več objektov po poizvedbi
+     * - Deluje samo online, offline vrže napako
+     * - Izbriše iz serverja, dexie in in-mem
+     */
+    hardDelete<T extends DbEntity>(collection: string, query: QuerySpec<T>): Promise<number>;
+    /**
+     * Preveri povezljivost s serverjem
+     * @param timeoutMs Timeout v milisekundah
+     * @returns true če je server dosegljiv, false sicer
+     */
+    ping(timeoutMs?: number): Promise<boolean>;
+    /** Sproži sinhronizacijo s serverjem */
+    sync(): Promise<void>;
+    /** Ali je sinhronizacija v teku */
+    isSyncing(): boolean;
+    /**
+     * Izvede batch upsert na serverju
+     * - Deluje samo online, offline vrže napako
+     * - Ne posodablja dexie ali in-mem baze
+     * - Uporabljeno za operacije, ki ne potrebujejo lokalne sinhronizacije
+     */
+    upsertBatch<T extends DbEntity>(collection: string, batch: BatchSpec<T>): Promise<T[]>;
+    /** Vrne vse objekte iz in-mem baze za dano kolekcijo */
+    getMemoryCollection<T extends DbEntity>(collection: string): T[];
+    /** Vrne konfigurirani debounce čas v ms */
+    getDebounceMs(): number;
+}

package/dist/types/PublishRevsPayload.d.ts

@@ -0,0 +1,66 @@
+import type { Timestamp } from "mongodb";
+import type { Id } from "./DbEntity";
+export type PublishableOperation = 'insert' | 'update' | 'updateMany' | 'deleteMany' | 'delete' | 'batch';
+type PublishRevsPayloadBase = {
+    db: string;
+    collection: string;
+};
+export type PublishRevsPayloadInsert = PublishRevsPayloadBase & {
+    operation: 'insert';
+    _id: Id;
+    _ts: Timestamp;
+    _rev: number;
+    enquireLastTs?: boolean;
+};
+export type PublishRevsPayloadUpdate = PublishRevsPayloadBase & {
+    operation: 'update';
+    _id: Id;
+    _ts: Timestamp;
+    _rev: number;
+    enquireLastTs?: boolean;
+};
+export type PublishRevsPayloadDelete = PublishRevsPayloadBase & {
+    operation: 'delete';
+    _id: Id;
+    _ts: Timestamp;
+    _rev: number;
+    enquireLastTs?: boolean;
+};
+export type PublishRevsPayloadUpdateMany = PublishRevsPayloadBase & {
+    operation: 'updateMany';
+    enquireLastTs: true;
+};
+export type PublishRevsPayloadDeleteMany = PublishRevsPayloadBase & {
+    operation: 'deleteMany';
+    enquireLastTs: true;
+};
+export type PublishRevsPayloadBatchItem = {
+    operation: PublishableOperation;
+    _id: Id;
+    _ts: Timestamp;
+};
+export type PublishRevsPayloadBatch = PublishRevsPayloadBase & {
+    operation: 'batch';
+    data: PublishRevsPayloadBatchItem[];
+};
+/**
+ * Notifikacija serverja, da je bil objekt spremenjen
+ */
+export type PublishRevsPayload = PublishRevsPayloadInsert | PublishRevsPayloadUpdate | PublishRevsPayloadDelete | PublishRevsPayloadUpdateMany | PublishRevsPayloadDeleteMany | PublishRevsPayloadBatch;
+export type PublishRevsSpec = {
+    channel: string;
+    payload: PublishRevsPayload;
+    user?: string;
+};
+export type PublishDataSpec = {
+    channel: string;
+    payload: {
+        db: string;
+        collection: string;
+        operation: PublishableOperation;
+        data: any;
+    };
+    user?: string;
+};
+export type PublishSpec = PublishDataSpec | PublishRevsSpec;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export type { Id, Entity, IdOrEntity, DbEntity, LocalDbEntity } from "./DbEntity";
+export type { PublishableOperation, PublishRevsPayloadInsert, PublishRevsPayloadUpdate, PublishRevsPayloadDelete, PublishRevsPayloadUpdateMany, PublishRevsPayloadDeleteMany, PublishRevsPayloadBatchItem, PublishRevsPayloadBatch, PublishRevsPayload, PublishRevsSpec, PublishDataSpec, PublishSpec, } from "./PublishRevsPayload";
+export type { Obj, QuerySpec, Projection, QueryOpts, KeyOf, InsertKeyOf, InsertSpec, UpdateSpec, BatchSpec, UpsertOptions, GetNewerSpec, I_RestInterface as RestInterface, } from "./I_RestInterface";
+export type { I_InMemDb as InMemDb } from "./I_InMemDb";
+export type { I_DexieDb as DexieDb, SyncMeta } from "./I_DexieDb";
+export type { I_ServerUpdateNotifier as ServerUpdateNotifier, ServerUpdateCallback } from "./I_ServerUpdateNotifier";
+export type { I_SyncedDb as SyncedDb, SyncedDbConfig, CollectionConfig, SyncInfo } from "./I_SyncedDb";
+export type { CollectionConfig as CollectionConfigFull } from "./CollectionConfig";

package/dist/utils/conflictResolution.d.ts

@@ -0,0 +1,19 @@
+import type { DbEntity } from "../types/DbEntity";
+/**
+ * Razreši konflikt med lokalnim in serverskim objektom po SPEC logiki:
+ *
+ * 1. Če ima lokalni objekt _rev in ima objekt s serverja nižji ali isti _rev, ignoriramo server
+ * 2. Polja, ki niso array in niso object:
+ *    - če lokalna verzija nima polja, zunanja pa ga ima, polje dodamo
+ *    - če imata oba objekta polje, vrednost s serverja zavržemo
+ * 3. Polja tipa array:
+ *    - če lokalni objekt nima polja, ga dodamo
+ *    - če je tip podatkov string[], shranimo deduplicirano unijo
+ *    - če je tip podatkov Object[]:
+ *      - elemente brez _id dodamo v lokalni array
+ *      - objekte z _id primerjamo rekurzivno
+ * 4. Če je tip podatkov Record<string, Object>:
+ *    - za vsak key, ki ga ni v lokalnem objektu, dodamo vrednost
+ *    - za vsak key, ki obstaja, primerjamo rekurzivno
+ */
+export declare function resolveConflict<T extends DbEntity>(local: T, external: T): T;

package/dist/utils/crashRecovery.d.ts

@@ -0,0 +1,27 @@
+import type { LocalDbEntity, Id } from "../types/DbEntity";
+interface PendingWrite {
+    tenant: string;
+    collection: string;
+    id: string;
+    data: LocalDbEntity;
+    timestamp: number;
+}
+/**
+ * Shrani pending write v localStorage pred zapisom v Dexie
+ * Zagotavlja crash resilience - če se tab zapre ali crashne med debounce
+ */
+export declare function savePendingWrite(tenant: string, collection: string, id: Id, data: LocalDbEntity): void;
+/**
+ * Odstrani pending write iz localStorage po uspešnem zapisu v Dexie
+ */
+export declare function clearPendingWrite(tenant: string, collection: string, id: Id): void;
+/**
+ * Pridobi vse pending writes za danega tenanta
+ * Pokliče se ob inicializaciji za recovery
+ */
+export declare function getPendingWrites(tenant: string): PendingWrite[];
+/**
+ * Počisti vse pending writes za danega tenanta
+ */
+export declare function clearAllPendingWrites(tenant: string): void;
+export {};

package/dist/utils/localQuery.d.ts

@@ -0,0 +1,11 @@
+import type { QuerySpec } from "../types/I_RestInterface";
+import type { DbEntity } from "../types/DbEntity";
+/**
+ * Preveri, ali objekt ustreza MongoDB-style query specifikaciji
+ * Podpira osnovne operatorje: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $exists, $regex
+ */
+export declare function matchesQuery<T extends DbEntity>(item: T, query: QuerySpec<T>): boolean;
+/**
+ * Filtriraj array objektov po query
+ */
+export declare function filterByQuery<T extends DbEntity>(items: T[], query?: QuerySpec<T>): T[];

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "cry-synced-db-client",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "bun run clean && bun run build:js && bun run build:types",
+    "build:js": "bun build ./src/index.ts --outdir ./dist --target browser --format esm --external dexie --external bson --external cry-helpers --external notepack.io",
+    "build:types": "tsc --emitDeclarationOnly --outDir dist",
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "bson": "^7.0.0",
+    "cry-db": "^2.4.11",
+    "dexie": "^4.2.1",
+    "fake-indexeddb": "^6.2.5",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "cry-helpers": "^2.1.180",
+    "notepack": "^0.0.2",
+    "notepack.io": "^3.0.1",
+    "undici": "^7.18.2"
+  },
+  "peerDependencies": {
+    "bson": "^6.0.0 || ^7.0.0",
+    "dexie": "^4.0.0"
+  }
+}