pomegranate-db 0.1.0

package/dist/database/Database.js

@@ -0,0 +1,245 @@
+"use strict";
+/**
+ * Database — the top-level entry point.
+ *
+ * The Database owns the adapter, manages collections, and provides
+ * the `write()` transactional boundary.
+ *
+ * Usage:
+ *   const db = new Database({
+ *     adapter: new SQLiteAdapter({ databaseName: 'app.db' }),
+ *     models: [Post, User, Comment],
+ *   });
+ *
+ *   await db.write(async () => {
+ *     await db.get(Post).create({ title: 'Hello' });
+ *   });
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+const Collection_1 = require("../collection/Collection");
+const Subject_1 = require("../observable/Subject");
+// ─── Database class ────────────────────────────────────────────────────────
+class Database {
+    config;
+    _adapter;
+    _collections = new Map();
+    _modelMap = new Map();
+    _initialized = false;
+    _isInWriter = false;
+    _writeQueue = [];
+    _isProcessingQueue = false;
+    _events$ = new Subject_1.Subject();
+    _schemaVersion;
+    constructor(config) {
+        this.config = config;
+        this._adapter = config.adapter;
+        this._schemaVersion = config.schemaVersion ?? 1;
+        // Register all model classes
+        for (const modelClass of config.models) {
+            const schema = modelClass.schema;
+            if (!schema) {
+                throw new Error('Model class is missing static schema property');
+            }
+            this._modelMap.set(schema.table, modelClass);
+            this._collections.set(schema.table, new Collection_1.Collection(this, modelClass));
+        }
+    }
+    // ─── Initialization ──────────────────────────────────────────────────
+    /**
+     * Initialize the database. Must be called before any operations.
+     * Creates tables if they don't exist.
+     */
+    async initialize() {
+        if (this._initialized)
+            return;
+        const dbSchema = this._buildDatabaseSchema();
+        await this._adapter.initialize(dbSchema);
+        this._initialized = true;
+        this._events$.next({ type: 'initialized' });
+    }
+    _buildDatabaseSchema() {
+        const tables = Array.from(this._collections.values()).map((collection) => {
+            const schema = collection.schema;
+            const columns = schema.columns.map((col) => ({
+                name: col.columnName,
+                type: col.type,
+                isOptional: col.isOptional,
+                isIndexed: col.isIndexed,
+            }));
+            return {
+                name: schema.table,
+                columns,
+            };
+        });
+        return {
+            version: this._schemaVersion,
+            tables,
+        };
+    }
+    // ─── Collection Access ──────────────────────────────────────────────
+    /**
+     * Get the collection for a model class.
+     */
+    get(modelClass) {
+        const table = modelClass.schema.table;
+        const collection = this._collections.get(table);
+        if (!collection) {
+            throw new Error(`No collection registered for table "${table}"`);
+        }
+        return collection;
+    }
+    /**
+     * Get a collection by table name.
+     */
+    collection(table) {
+        const collection = this._collections.get(table);
+        if (!collection) {
+            throw new Error(`No collection registered for table "${table}"`);
+        }
+        return collection;
+    }
+    /**
+     * All registered collections.
+     */
+    get collections() {
+        return Array.from(this._collections.values());
+    }
+    // ─── Write Transaction ──────────────────────────────────────────────
+    /**
+     * Execute a write transaction.
+     *
+     * All mutations (create, update, delete) must happen inside a write() call.
+     * Write calls are serialized — only one runs at a time.
+     */
+    async write(fn) {
+        this._ensureInitialized();
+        return new Promise((resolve, reject) => {
+            this._writeQueue.push(async () => {
+                this._isInWriter = true;
+                this._events$.next({ type: 'write_started' });
+                try {
+                    const result = await fn();
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+                finally {
+                    this._isInWriter = false;
+                    this._events$.next({ type: 'write_completed' });
+                }
+            });
+            this._processWriteQueue();
+        });
+    }
+    async _processWriteQueue() {
+        if (this._isProcessingQueue)
+            return;
+        this._isProcessingQueue = true;
+        while (this._writeQueue.length > 0) {
+            const fn = this._writeQueue.shift();
+            await fn();
+        }
+        this._isProcessingQueue = false;
+    }
+    /**
+     * @internal Throw if not inside a writer.
+     */
+    _ensureInWriter(action) {
+        if (!this._isInWriter) {
+            throw new Error(`${action} must be called inside db.write(). ` +
+                'Wrap your mutation in: await db.write(async () => { ... })');
+        }
+    }
+    // ─── Batch ──────────────────────────────────────────────────────────
+    /**
+     * Execute a batch of operations atomically.
+     * Must be called inside `db.write()`.
+     */
+    async batch(operations) {
+        this._ensureInWriter('Database.batch()');
+        await this._adapter.batch(operations);
+    }
+    /** @internal used by Model */
+    async _batch(operations) {
+        await this._adapter.batch(operations);
+    }
+    // ─── Sync ──────────────────────────────────────────────────────────
+    /**
+     * Run a sync cycle.
+     * See sync/index.ts for the full implementation.
+     */
+    async sync(opts) {
+        this._ensureInitialized();
+        // Import sync dynamically to keep the module boundary clean
+        const { performSync } = await Promise.resolve().then(() => __importStar(require('../sync')));
+        await performSync(this, opts);
+    }
+    // ─── Reset ──────────────────────────────────────────────────────────
+    /**
+     * Completely reset the database — drops all data.
+     */
+    async reset() {
+        await this._adapter.reset();
+        for (const collection of this._collections.values()) {
+            collection._clearCache();
+        }
+        this._events$.next({ type: 'reset' });
+    }
+    // ─── Events ──────────────────────────────────────────────────────────
+    get events$() {
+        return this._events$;
+    }
+    // ─── Close ──────────────────────────────────────────────────────────
+    async close() {
+        await this._adapter.close();
+    }
+    // ─── Helpers ──────────────────────────────────────────────────────────
+    _ensureInitialized() {
+        if (!this._initialized) {
+            throw new Error('Database is not initialized. Call `await db.initialize()` first.');
+        }
+    }
+    /**
+     * The tables this database manages.
+     */
+    get tables() {
+        return Array.from(this._collections.keys());
+    }
+}
+exports.Database = Database;
+//# sourceMappingURL=Database.js.map

package/dist/database/index.d.ts

@@ -0,0 +1,2 @@
+export { Database } from './Database';
+export type { DatabaseConfig, DatabaseEvent } from './Database';

package/dist/database/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+var Database_1 = require("./Database");
+Object.defineProperty(exports, "Database", { enumerable: true, get: function () { return Database_1.Database; } });
+//# sourceMappingURL=index.js.map

package/dist/encryption/index.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Encryption layer — transparent encrypt/decrypt for storage adapters.
+ *
+ * Wraps a StorageAdapter, encrypting record values before writes
+ * and decrypting after reads. Uses AES-GCM (Web Crypto API or Node crypto).
+ *
+ * The encryption is transparent to the model/collection layer.
+ * Only user-data columns are encrypted; id, _status, _changed are stored in plaintext
+ * so the adapter can still query by them.
+ */
+import type { StorageAdapter, Migration } from '../adapters/types';
+import type { QueryDescriptor, SearchDescriptor, BatchOperation } from '../query/types';
+import type { DatabaseSchema, RawRecord } from '../schema/types';
+export declare class EncryptionManager {
+    private _key;
+    private _keyProvider;
+    constructor(keyProvider: () => Promise<Uint8Array>);
+    getKey(): Promise<Uint8Array>;
+    /** Encrypt a string value */
+    encrypt(plaintext: string): Promise<string>;
+    /** Decrypt a string value */
+    decrypt(ciphertext: string): Promise<string>;
+}
+/**
+ * Wraps a StorageAdapter to provide transparent encryption.
+ * Only user-data columns are encrypted. Sync metadata and IDs remain in plaintext.
+ */
+export declare class EncryptingAdapter implements StorageAdapter {
+    private _inner;
+    private _encryption;
+    constructor(inner: StorageAdapter, keyProvider: () => Promise<Uint8Array>);
+    initialize(schema: DatabaseSchema): Promise<void>;
+    find(query: QueryDescriptor): Promise<RawRecord[]>;
+    count(query: QueryDescriptor): Promise<number>;
+    findById(table: string, id: string): Promise<RawRecord | null>;
+    insert(table: string, raw: RawRecord): Promise<void>;
+    update(table: string, raw: RawRecord): Promise<void>;
+    markAsDeleted(table: string, id: string): Promise<void>;
+    destroyPermanently(table: string, id: string): Promise<void>;
+    batch(operations: BatchOperation[]): Promise<void>;
+    search(descriptor: SearchDescriptor): Promise<{
+        records: RawRecord[];
+        total: number;
+    }>;
+    getLocalChanges(tables: string[]): Promise<Record<string, {
+        created: RawRecord[];
+        updated: RawRecord[];
+        deleted: string[];
+    }>>;
+    applyRemoteChanges(changes: Record<string, {
+        created: RawRecord[];
+        updated: RawRecord[];
+        deleted: string[];
+    }>): Promise<void>;
+    markAsSynced(table: string, ids: string[]): Promise<void>;
+    getSchemaVersion(): Promise<number>;
+    migrate(migrations: Migration[]): Promise<void>;
+    reset(): Promise<void>;
+    close(): Promise<void>;
+    private _encryptRecord;
+    private _decryptRecord;
+}

package/dist/encryption/index.js

@@ -0,0 +1,276 @@
+"use strict";
+/**
+ * Encryption layer — transparent encrypt/decrypt for storage adapters.
+ *
+ * Wraps a StorageAdapter, encrypting record values before writes
+ * and decrypting after reads. Uses AES-GCM (Web Crypto API or Node crypto).
+ *
+ * The encryption is transparent to the model/collection layer.
+ * Only user-data columns are encrypted; id, _status, _changed are stored in plaintext
+ * so the adapter can still query by them.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptingAdapter = exports.EncryptionManager = void 0;
+const nodeCrypto_1 = require("./nodeCrypto");
+// ─── Columns that are never encrypted ──────────────────────────────────
+const PLAINTEXT_COLUMNS = new Set(['id', '_status', '_changed']);
+// ─── Encryption Manager ───────────────────────────────────────────────
+class EncryptionManager {
+    _key = null;
+    _keyProvider;
+    constructor(keyProvider) {
+        this._keyProvider = keyProvider;
+    }
+    async getKey() {
+        if (!this._key) {
+            this._key = await this._keyProvider();
+        }
+        return this._key;
+    }
+    /** Encrypt a string value */
+    async encrypt(plaintext) {
+        const key = await this.getKey();
+        const iv = await randomBytes(12);
+        const encoder = new TextEncoder();
+        const data = encoder.encode(plaintext);
+        if (globalThis.crypto !== undefined && globalThis.crypto.subtle) {
+            // Web Crypto API
+            const cryptoKey = await globalThis.crypto.subtle.importKey('raw', key.buffer, { name: 'AES-GCM' }, false, ['encrypt']);
+            const encrypted = await globalThis.crypto.subtle.encrypt({ name: 'AES-GCM', iv: iv.buffer }, cryptoKey, data.buffer);
+            return encodeBase64(iv) + ':' + encodeBase64(new Uint8Array(encrypted));
+        }
+        // Fallback: Node.js crypto
+        if (nodeCrypto_1.isNodeCryptoAvailable) {
+            try {
+                const cipher = (0, nodeCrypto_1.createCipheriv)('aes-256-gcm', key, iv);
+                const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+                const tag = cipher.getAuthTag();
+                return encodeBase64(iv) + ':' + encodeBase64(encrypted) + ':' + encodeBase64(tag);
+            }
+            catch {
+                throw new Error('No crypto implementation available for encryption');
+            }
+        }
+        throw new Error('No crypto implementation available for encryption');
+    }
+    /** Decrypt a string value */
+    async decrypt(ciphertext) {
+        const key = await this.getKey();
+        const parts = ciphertext.split(':');
+        if (globalThis.crypto !== undefined && globalThis.crypto.subtle) {
+            // Web Crypto API
+            const iv = decodeBase64(parts[0]);
+            const data = decodeBase64(parts[1]);
+            const cryptoKey = await globalThis.crypto.subtle.importKey('raw', key.buffer, { name: 'AES-GCM' }, false, ['decrypt']);
+            const decrypted = await globalThis.crypto.subtle.decrypt({ name: 'AES-GCM', iv: iv.buffer }, cryptoKey, data.buffer);
+            return new TextDecoder().decode(decrypted);
+        }
+        // Fallback: Node.js crypto
+        if (nodeCrypto_1.isNodeCryptoAvailable) {
+            try {
+                const iv = decodeBase64(parts[0]);
+                const data = decodeBase64(parts[1]);
+                const tag = decodeBase64(parts[2]);
+                const decipher = (0, nodeCrypto_1.createDecipheriv)('aes-256-gcm', key, iv);
+                decipher.setAuthTag(tag);
+                const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
+                return new TextDecoder().decode(decrypted);
+            }
+            catch (error) {
+                throw new Error(`Decryption failed: ${error}`, { cause: error });
+            }
+        }
+        throw new Error('No crypto implementation available for decryption');
+    }
+}
+exports.EncryptionManager = EncryptionManager;
+// ─── Encrypting Adapter Wrapper ──────────────────────────────────────────
+/**
+ * Wraps a StorageAdapter to provide transparent encryption.
+ * Only user-data columns are encrypted. Sync metadata and IDs remain in plaintext.
+ */
+class EncryptingAdapter {
+    _inner;
+    _encryption;
+    constructor(inner, keyProvider) {
+        this._inner = inner;
+        this._encryption = new EncryptionManager(keyProvider);
+    }
+    async initialize(schema) {
+        await this._inner.initialize(schema);
+    }
+    async find(query) {
+        // NOTE: Encrypted columns cannot be queried by value.
+        // Queries should only filter on plaintext columns (id, _status, etc.)
+        // or indexed columns stored unencrypted.
+        const rows = await this._inner.find(query);
+        return Promise.all(rows.map((r) => this._decryptRecord(r)));
+    }
+    async count(query) {
+        return this._inner.count(query);
+    }
+    async findById(table, id) {
+        const raw = await this._inner.findById(table, id);
+        if (!raw)
+            return null;
+        return this._decryptRecord(raw);
+    }
+    async insert(table, raw) {
+        const encrypted = await this._encryptRecord(raw);
+        await this._inner.insert(table, encrypted);
+    }
+    async update(table, raw) {
+        const encrypted = await this._encryptRecord(raw);
+        await this._inner.update(table, encrypted);
+    }
+    async markAsDeleted(table, id) {
+        await this._inner.markAsDeleted(table, id);
+    }
+    async destroyPermanently(table, id) {
+        await this._inner.destroyPermanently(table, id);
+    }
+    async batch(operations) {
+        const encrypted = [];
+        for (const op of operations) {
+            if (op.rawRecord && (op.type === 'create' || op.type === 'update')) {
+                const encRecord = await this._encryptRecord(op.rawRecord);
+                encrypted.push({ ...op, rawRecord: encRecord });
+            }
+            else {
+                encrypted.push(op);
+            }
+        }
+        await this._inner.batch(encrypted);
+    }
+    async search(descriptor) {
+        // Full-text search on encrypted data is not possible.
+        // This will only work if search fields are stored unencrypted.
+        const result = await this._inner.search(descriptor);
+        const records = await Promise.all(result.records.map((r) => this._decryptRecord(r)));
+        return { records, total: result.total };
+    }
+    async getLocalChanges(tables) {
+        const changes = await this._inner.getLocalChanges(tables);
+        const result = {};
+        for (const [table, tc] of Object.entries(changes)) {
+            result[table] = {
+                created: await Promise.all(tc.created.map((r) => this._decryptRecord(r))),
+                updated: await Promise.all(tc.updated.map((r) => this._decryptRecord(r))),
+                deleted: tc.deleted,
+            };
+        }
+        return result;
+    }
+    async applyRemoteChanges(changes) {
+        const encrypted = {};
+        for (const [table, tc] of Object.entries(changes)) {
+            encrypted[table] = {
+                created: await Promise.all(tc.created.map((r) => this._encryptRecord(r))),
+                updated: await Promise.all(tc.updated.map((r) => this._encryptRecord(r))),
+                deleted: tc.deleted,
+            };
+        }
+        await this._inner.applyRemoteChanges(encrypted);
+    }
+    async markAsSynced(table, ids) {
+        await this._inner.markAsSynced(table, ids);
+    }
+    async getSchemaVersion() {
+        return this._inner.getSchemaVersion();
+    }
+    async migrate(migrations) {
+        await this._inner.migrate(migrations);
+    }
+    async reset() {
+        await this._inner.reset();
+    }
+    async close() {
+        await this._inner.close();
+    }
+    // ─── Internal helpers ──────────────────────────────────────────────
+    async _encryptRecord(raw) {
+        const encrypted = {};
+        for (const [key, value] of Object.entries(raw)) {
+            if (PLAINTEXT_COLUMNS.has(key)) {
+                encrypted[key] = value;
+            }
+            else if (value === null || value === undefined) {
+                encrypted[key] = value;
+            }
+            else {
+                encrypted[key] = await this._encryption.encrypt(String(value));
+            }
+        }
+        return encrypted;
+    }
+    async _decryptRecord(raw) {
+        const decrypted = {};
+        for (const [key, value] of Object.entries(raw)) {
+            if (PLAINTEXT_COLUMNS.has(key)) {
+                decrypted[key] = value;
+            }
+            else if (value === null || value === undefined) {
+                decrypted[key] = value;
+            }
+            else if (typeof value === 'string' && value.includes(':')) {
+                // Looks like encrypted data
+                try {
+                    decrypted[key] = await this._encryption.decrypt(value);
+                }
+                catch {
+                    // Not encrypted or corrupted — pass through
+                    decrypted[key] = value;
+                }
+            }
+            else {
+                decrypted[key] = value;
+            }
+        }
+        return decrypted;
+    }
+}
+exports.EncryptingAdapter = EncryptingAdapter;
+// ─── Utility functions ──────────────────────────────────────────────────
+async function randomBytes(length) {
+    if (globalThis.crypto !== undefined && globalThis.crypto.getRandomValues) {
+        const buf = new Uint8Array(length);
+        globalThis.crypto.getRandomValues(buf);
+        return buf;
+    }
+    if (nodeCrypto_1.isNodeCryptoAvailable) {
+        try {
+            return (0, nodeCrypto_1.randomBytesNode)(length);
+        }
+        catch { /* fall through to Math.random */ }
+    }
+    // Last resort: Math.random (NOT cryptographically secure)
+    const buf = new Uint8Array(length);
+    for (let i = 0; i < length; i++) {
+        buf[i] = Math.floor(Math.random() * 256);
+    }
+    return buf;
+}
+function encodeBase64(data) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(data).toString('base64');
+    }
+    // Browser
+    let binary = '';
+    for (const datum of data) {
+        binary += String.fromCodePoint(datum);
+    }
+    return btoa(binary);
+}
+function decodeBase64(str) {
+    if (typeof Buffer !== 'undefined') {
+        return new Uint8Array(Buffer.from(str, 'base64'));
+    }
+    // Browser
+    const binary = atob(str);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.codePointAt(i);
+    }
+    return bytes;
+}
+//# sourceMappingURL=index.js.map

package/dist/encryption/nodeCrypto.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Node.js crypto provider — used on Node.js (tests, server-side).
+ *
+ * Metro bundler (React Native) will pick nodeCrypto.native.ts instead,
+ * which doesn't import the Node `crypto` module.
+ */
+export declare function createCipheriv(algorithm: string, key: Uint8Array, iv: Uint8Array): {
+    update(data: Uint8Array): Buffer;
+    final(): Buffer;
+    getAuthTag(): Buffer;
+};
+export declare function createDecipheriv(algorithm: string, key: Uint8Array, iv: Uint8Array): {
+    setAuthTag(tag: Uint8Array): void;
+    update(data: Uint8Array): Buffer;
+    final(): Buffer;
+};
+export declare function randomBytesNode(length: number): Uint8Array;
+export declare const isNodeCryptoAvailable = true;

package/dist/encryption/nodeCrypto.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Node.js crypto provider — used on Node.js (tests, server-side).
+ *
+ * Metro bundler (React Native) will pick nodeCrypto.native.ts instead,
+ * which doesn't import the Node `crypto` module.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNodeCryptoAvailable = void 0;
+exports.createCipheriv = createCipheriv;
+exports.createDecipheriv = createDecipheriv;
+exports.randomBytesNode = randomBytesNode;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const crypto = require('crypto');
+function createCipheriv(algorithm, key, iv) {
+    return crypto.createCipheriv(algorithm, key, iv);
+}
+function createDecipheriv(algorithm, key, iv) {
+    return crypto.createDecipheriv(algorithm, key, iv);
+}
+function randomBytesNode(length) {
+    return new Uint8Array(crypto.randomBytes(length));
+}
+exports.isNodeCryptoAvailable = true;
+//# sourceMappingURL=nodeCrypto.js.map

package/dist/encryption/nodeCrypto.native.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Node.js crypto provider — React Native stub.
+ *
+ * Metro picks .native.ts files over .ts for React Native bundles.
+ * This avoids importing the Node `crypto` module which doesn't exist
+ * in React Native and would cause Metro bundling to fail.
+ *
+ * React Native should use globalThis.crypto (Web Crypto API) instead.
+ */
+export declare function createCipheriv(_algorithm: string, _key: Uint8Array, _iv: Uint8Array): never;
+export declare function createDecipheriv(_algorithm: string, _key: Uint8Array, _iv: Uint8Array): never;
+export declare function randomBytesNode(_length: number): never;
+export declare const isNodeCryptoAvailable = false;

package/dist/encryption/nodeCrypto.native.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Node.js crypto provider — React Native stub.
+ *
+ * Metro picks .native.ts files over .ts for React Native bundles.
+ * This avoids importing the Node `crypto` module which doesn't exist
+ * in React Native and would cause Metro bundling to fail.
+ *
+ * React Native should use globalThis.crypto (Web Crypto API) instead.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNodeCryptoAvailable = void 0;
+exports.createCipheriv = createCipheriv;
+exports.createDecipheriv = createDecipheriv;
+exports.randomBytesNode = randomBytesNode;
+function createCipheriv(_algorithm, _key, _iv) {
+    throw new Error('Node.js crypto is not available in React Native. Use Web Crypto API via globalThis.crypto.subtle.');
+}
+function createDecipheriv(_algorithm, _key, _iv) {
+    throw new Error('Node.js crypto is not available in React Native. Use Web Crypto API via globalThis.crypto.subtle.');
+}
+function randomBytesNode(_length) {
+    throw new Error('Node.js crypto is not available in React Native. Use globalThis.crypto.getRandomValues.');
+}
+exports.isNodeCryptoAvailable = false;
+//# sourceMappingURL=nodeCrypto.native.js.map