opencode-mem 1.0.0

package/dist/services/embedding.js

@@ -0,0 +1,77 @@
+import { pipeline, env } from "@xenova/transformers";
+import { CONFIG } from "../config.js";
+import { log } from "./logger.js";
+env.allowLocalModels = true;
+env.allowRemoteModels = true;
+env.cacheDir = CONFIG.storagePath + "/.cache";
+const TIMEOUT_MS = 30000;
+function withTimeout(promise, ms) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${ms}ms`)), ms)),
+    ]);
+}
+export class EmbeddingService {
+    pipe = null;
+    initPromise = null;
+    isWarmedUp = false;
+    async warmup(progressCallback) {
+        if (this.isWarmedUp)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = (async () => {
+            try {
+                if (CONFIG.embeddingApiUrl && CONFIG.embeddingApiKey) {
+                    log("Using OpenAI-compatible API for embeddings");
+                    this.isWarmedUp = true;
+                    return;
+                }
+                log("Downloading embedding model", { model: CONFIG.embeddingModel });
+                this.pipe = await pipeline("feature-extraction", CONFIG.embeddingModel, {
+                    progress_callback: progressCallback,
+                });
+                this.isWarmedUp = true;
+                log("Embedding model ready");
+            }
+            catch (error) {
+                this.initPromise = null;
+                log("Failed to initialize embedding model", { error: String(error) });
+                throw error;
+            }
+        })();
+        return this.initPromise;
+    }
+    async embed(text) {
+        if (!this.isWarmedUp && !this.initPromise) {
+            await this.warmup();
+        }
+        if (this.initPromise) {
+            await this.initPromise;
+        }
+        if (CONFIG.embeddingApiUrl && CONFIG.embeddingApiKey) {
+            const response = await fetch(`${CONFIG.embeddingApiUrl}/embeddings`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${CONFIG.embeddingApiKey}`,
+                },
+                body: JSON.stringify({
+                    input: text,
+                    model: CONFIG.embeddingModel,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`API embedding failed: ${response.statusText}`);
+            }
+            const data = await response.json();
+            return new Float32Array(data.data[0].embedding);
+        }
+        const output = await this.pipe(text, { pooling: "mean", normalize: true });
+        return new Float32Array(output.data);
+    }
+    async embedWithTimeout(text) {
+        return withTimeout(this.embed(text), TIMEOUT_MS);
+    }
+}
+export const embeddingService = new EmbeddingService();

package/dist/services/jsonc.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Strips comments from JSONC content while respecting string boundaries.
+ * Handles // and /* comments, URLs in strings, and escaped quotes.
+ * Also removes trailing commas to support more relaxed JSONC format.
+ */
+export declare function stripJsoncComments(content: string): string;
+//# sourceMappingURL=jsonc.d.ts.map

package/dist/services/jsonc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonc.d.ts","sourceRoot":"","sources":["../../src/services/jsonc.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA+E1D"}

package/dist/services/jsonc.js

@@ -0,0 +1,76 @@
+/**
+ * Strips comments from JSONC content while respecting string boundaries.
+ * Handles // and /* comments, URLs in strings, and escaped quotes.
+ * Also removes trailing commas to support more relaxed JSONC format.
+ */
+export function stripJsoncComments(content) {
+    let result = "";
+    let i = 0;
+    let inString = false;
+    let inSingleLineComment = false;
+    let inMultiLineComment = false;
+    while (i < content.length) {
+        const char = content[i];
+        const nextChar = content[i + 1];
+        if (!inSingleLineComment && !inMultiLineComment) {
+            if (char === '"') {
+                // Count consecutive backslashes before this quote
+                let backslashCount = 0;
+                let j = i - 1;
+                while (j >= 0 && content[j] === "\\") {
+                    backslashCount++;
+                    j--;
+                }
+                // Quote is escaped only if preceded by ODD number of backslashes
+                // e.g., \" = escaped, \\" = not escaped (escaped backslash + quote)
+                if (backslashCount % 2 === 0) {
+                    inString = !inString;
+                }
+                result += char;
+                i++;
+                continue;
+            }
+        }
+        if (inString) {
+            result += char;
+            i++;
+            continue;
+        }
+        if (!inSingleLineComment && !inMultiLineComment) {
+            if (char === "/" && nextChar === "/") {
+                inSingleLineComment = true;
+                i += 2;
+                continue;
+            }
+            if (char === "/" && nextChar === "*") {
+                inMultiLineComment = true;
+                i += 2;
+                continue;
+            }
+        }
+        if (inSingleLineComment) {
+            if (char === "\n") {
+                inSingleLineComment = false;
+                result += char;
+            }
+            i++;
+            continue;
+        }
+        if (inMultiLineComment) {
+            if (char === "*" && nextChar === "/") {
+                inMultiLineComment = false;
+                i += 2;
+                continue;
+            }
+            if (char === "\n") {
+                result += char;
+            }
+            i++;
+            continue;
+        }
+        result += char;
+        i++;
+    }
+    // Remove trailing commas before } or ]
+    return result.replace(/,\s*([}\]])/g, "$1");
+}

package/dist/services/logger.d.ts

@@ -0,0 +1,2 @@
+export declare function log(message: string, data?: unknown): void;
+//# sourceMappingURL=logger.d.ts.map

package/dist/services/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/services/logger.ts"],"names":[],"mappings":"AAaA,wBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,QAMlD"}

package/dist/services/logger.js

@@ -0,0 +1,16 @@
+import { appendFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+const LOG_DIR = join(homedir(), ".opencode-mem");
+const LOG_FILE = join(LOG_DIR, "opencode-mem.log");
+if (!existsSync(LOG_DIR)) {
+    mkdirSync(LOG_DIR, { recursive: true });
+}
+writeFileSync(LOG_FILE, `\n--- Session started: ${new Date().toISOString()} ---\n`, { flag: "a" });
+export function log(message, data) {
+    const timestamp = new Date().toISOString();
+    const line = data
+        ? `[${timestamp}] ${message}: ${JSON.stringify(data)}\n`
+        : `[${timestamp}] ${message}\n`;
+    appendFileSync(LOG_FILE, line);
+}

package/dist/services/migration-service.d.ts

@@ -0,0 +1,42 @@
+export interface DimensionMismatch {
+    needsMigration: boolean;
+    configDimensions: number;
+    configModel: string;
+    shardMismatches: Array<{
+        shardId: number;
+        dbPath: string;
+        storedDimensions: number;
+        storedModel: string;
+        vectorCount: number;
+    }>;
+}
+export interface MigrationProgress {
+    phase: "preparing" | "re-embedding" | "cleanup" | "complete";
+    processed: number;
+    total: number;
+    currentShard?: string;
+}
+export interface MigrationResult {
+    success: boolean;
+    strategy: "fresh-start" | "re-embed";
+    deletedShards: number;
+    reEmbeddedMemories: number;
+    duration: number;
+    error?: string;
+}
+export declare class MigrationService {
+    private isRunning;
+    private progressCallback?;
+    detectDimensionMismatch(): Promise<DimensionMismatch>;
+    migrateToNewModel(strategy: "fresh-start" | "re-embed", progressCallback?: (progress: MigrationProgress) => void): Promise<MigrationResult>;
+    private freshStartMigration;
+    private reEmbedMigration;
+    private reportProgress;
+    getStatus(): {
+        isRunning: boolean;
+        configModel: string;
+        configDimensions: number;
+    };
+}
+export declare const migrationService: MigrationService;
+//# sourceMappingURL=migration-service.d.ts.map

package/dist/services/migration-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-service.d.ts","sourceRoot":"","sources":["../../src/services/migration-service.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,OAAO,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,KAAK,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,gBAAgB,EAAE,MAAM,CAAC;QACzB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,WAAW,GAAG,cAAc,GAAG,SAAS,GAAG,UAAU,CAAC;IAC7D,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,aAAa,GAAG,UAAU,CAAC;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,gBAAgB,CAAC,CAAwC;IAE3D,uBAAuB,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAoDrD,iBAAiB,CACrB,QAAQ,EAAE,aAAa,GAAG,UAAU,EACpC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,iBAAiB,KAAK,IAAI,GACvD,OAAO,CAAC,eAAe,CAAC;YA6Cb,mBAAmB;YAmDnB,gBAAgB;IA+I9B,OAAO,CAAC,cAAc;IAMtB,SAAS;;;;;CAOV;AAED,eAAO,MAAM,gBAAgB,kBAAyB,CAAC"}

package/dist/services/migration-service.js

@@ -0,0 +1,258 @@
+import { shardManager } from "./sqlite/shard-manager.js";
+import { connectionManager } from "./sqlite/connection-manager.js";
+import { vectorSearch } from "./sqlite/vector-search.js";
+import { embeddingService } from "./embedding.js";
+import { CONFIG } from "../config.js";
+import { log } from "./logger.js";
+export class MigrationService {
+    isRunning = false;
+    progressCallback;
+    async detectDimensionMismatch() {
+        const userShards = shardManager.getAllShards("user", "");
+        const projectShards = shardManager.getAllShards("project", "");
+        const allShards = [...userShards, ...projectShards];
+        const mismatches = [];
+        for (const shard of allShards) {
+            try {
+                const db = connectionManager.getConnection(shard.dbPath);
+                const metadataResult = db
+                    .prepare(`
+          SELECT key, value FROM shard_metadata 
+          WHERE key IN ('embedding_dimensions', 'embedding_model')
+        `)
+                    .all();
+                const metadata = Object.fromEntries(metadataResult.map((row) => [row.key, row.value]));
+                const storedDimensions = parseInt(metadata.embedding_dimensions || "0");
+                const storedModel = metadata.embedding_model || "unknown";
+                if (storedDimensions !== CONFIG.embeddingDimensions) {
+                    const vectorCount = vectorSearch.countAllVectors(db);
+                    mismatches.push({
+                        shardId: shard.id,
+                        dbPath: shard.dbPath,
+                        storedDimensions,
+                        storedModel,
+                        vectorCount,
+                    });
+                }
+            }
+            catch (error) {
+                log("Migration: error checking shard", {
+                    shardId: shard.id,
+                    error: String(error),
+                });
+            }
+        }
+        return {
+            needsMigration: mismatches.length > 0,
+            configDimensions: CONFIG.embeddingDimensions,
+            configModel: CONFIG.embeddingModel,
+            shardMismatches: mismatches,
+        };
+    }
+    async migrateToNewModel(strategy, progressCallback) {
+        if (this.isRunning) {
+            throw new Error("Migration already running");
+        }
+        this.isRunning = true;
+        this.progressCallback = progressCallback;
+        const startTime = Date.now();
+        try {
+            log("Migration: starting", { strategy, model: CONFIG.embeddingModel });
+            const mismatch = await this.detectDimensionMismatch();
+            if (!mismatch.needsMigration) {
+                return {
+                    success: true,
+                    strategy,
+                    deletedShards: 0,
+                    reEmbeddedMemories: 0,
+                    duration: Date.now() - startTime,
+                };
+            }
+            if (strategy === "fresh-start") {
+                return await this.freshStartMigration(mismatch, startTime);
+            }
+            else {
+                return await this.reEmbedMigration(mismatch, startTime);
+            }
+        }
+        catch (error) {
+            log("Migration: failed", { error: String(error) });
+            return {
+                success: false,
+                strategy,
+                deletedShards: 0,
+                reEmbeddedMemories: 0,
+                duration: Date.now() - startTime,
+                error: String(error),
+            };
+        }
+        finally {
+            this.isRunning = false;
+            this.progressCallback = undefined;
+        }
+    }
+    async freshStartMigration(mismatch, startTime) {
+        this.reportProgress({
+            phase: "preparing",
+            processed: 0,
+            total: mismatch.shardMismatches.length,
+        });
+        let deletedShards = 0;
+        for (const [index, shardInfo] of mismatch.shardMismatches.entries()) {
+            try {
+                this.reportProgress({
+                    phase: "cleanup",
+                    processed: index,
+                    total: mismatch.shardMismatches.length,
+                    currentShard: String(shardInfo.shardId),
+                });
+                shardManager.deleteShard(shardInfo.shardId);
+                deletedShards++;
+                log("Migration: deleted shard", {
+                    shardId: shardInfo.shardId,
+                    vectorCount: shardInfo.vectorCount,
+                });
+            }
+            catch (error) {
+                log("Migration: error deleting shard", {
+                    shardId: shardInfo.shardId,
+                    error: String(error),
+                });
+            }
+        }
+        this.reportProgress({
+            phase: "complete",
+            processed: mismatch.shardMismatches.length,
+            total: mismatch.shardMismatches.length,
+        });
+        return {
+            success: true,
+            strategy: "fresh-start",
+            deletedShards,
+            reEmbeddedMemories: 0,
+            duration: Date.now() - startTime,
+        };
+    }
+    async reEmbedMigration(mismatch, startTime) {
+        await embeddingService.warmup();
+        const totalMemories = mismatch.shardMismatches.reduce((sum, s) => sum + s.vectorCount, 0);
+        this.reportProgress({
+            phase: "preparing",
+            processed: 0,
+            total: totalMemories,
+        });
+        let reEmbeddedCount = 0;
+        let processedCount = 0;
+        for (const shardInfo of mismatch.shardMismatches) {
+            this.reportProgress({
+                phase: "re-embedding",
+                processed: processedCount,
+                total: totalMemories,
+                currentShard: String(shardInfo.shardId),
+            });
+            try {
+                const db = connectionManager.getConnection(shardInfo.dbPath);
+                const memories = vectorSearch.getAllMemories(db);
+                const tempMemories = [];
+                for (const memory of memories) {
+                    tempMemories.push({
+                        id: memory.id,
+                        content: memory.content,
+                        containerTag: memory.container_tag,
+                        type: memory.type,
+                        createdAt: memory.created_at,
+                        updatedAt: memory.updated_at,
+                        metadata: memory.metadata,
+                        displayName: memory.display_name,
+                        userName: memory.user_name,
+                        userEmail: memory.user_email,
+                        projectPath: memory.project_path,
+                        projectName: memory.project_name,
+                        gitRepoUrl: memory.git_repo_url,
+                        isPinned: memory.is_pinned || 0,
+                    });
+                }
+                shardManager.deleteShard(shardInfo.shardId);
+                for (const memory of tempMemories) {
+                    try {
+                        const vector = await embeddingService.embedWithTimeout(memory.content);
+                        const scope = memory.containerTag.includes("_user_") ? "user" : "project";
+                        const hash = memory.containerTag.split("_").slice(2).join("_");
+                        const newShard = shardManager.getWriteShard(scope, hash);
+                        const newDb = connectionManager.getConnection(newShard.dbPath);
+                        vectorSearch.insertVector(newDb, {
+                            id: memory.id,
+                            content: memory.content,
+                            vector,
+                            containerTag: memory.containerTag,
+                            type: memory.type || undefined,
+                            createdAt: memory.createdAt,
+                            updatedAt: memory.updatedAt,
+                            metadata: memory.metadata || undefined,
+                            displayName: memory.displayName || undefined,
+                            userName: memory.userName || undefined,
+                            userEmail: memory.userEmail || undefined,
+                            projectPath: memory.projectPath || undefined,
+                            projectName: memory.projectName || undefined,
+                            gitRepoUrl: memory.gitRepoUrl || undefined,
+                        });
+                        if (memory.isPinned === 1) {
+                            vectorSearch.pinMemory(newDb, memory.id);
+                        }
+                        shardManager.incrementVectorCount(newShard.id);
+                        reEmbeddedCount++;
+                        processedCount++;
+                        this.reportProgress({
+                            phase: "re-embedding",
+                            processed: processedCount,
+                            total: totalMemories,
+                            currentShard: String(shardInfo.shardId),
+                        });
+                    }
+                    catch (error) {
+                        log("Migration: error re-embedding memory", {
+                            memoryId: memory.id,
+                            error: String(error),
+                        });
+                        processedCount++;
+                    }
+                }
+                log("Migration: re-embedded shard", {
+                    shardId: shardInfo.shardId,
+                    count: tempMemories.length,
+                });
+            }
+            catch (error) {
+                log("Migration: error processing shard", {
+                    shardId: shardInfo.shardId,
+                    error: String(error),
+                });
+            }
+        }
+        this.reportProgress({
+            phase: "complete",
+            processed: totalMemories,
+            total: totalMemories,
+        });
+        return {
+            success: true,
+            strategy: "re-embed",
+            deletedShards: mismatch.shardMismatches.length,
+            reEmbeddedMemories: reEmbeddedCount,
+            duration: Date.now() - startTime,
+        };
+    }
+    reportProgress(progress) {
+        if (this.progressCallback) {
+            this.progressCallback(progress);
+        }
+    }
+    getStatus() {
+        return {
+            isRunning: this.isRunning,
+            configModel: CONFIG.embeddingModel,
+            configDimensions: CONFIG.embeddingDimensions,
+        };
+    }
+}
+export const migrationService = new MigrationService();

package/dist/services/privacy.d.ts

@@ -0,0 +1,4 @@
+export declare function containsPrivateTag(content: string): boolean;
+export declare function stripPrivateContent(content: string): string;
+export declare function isFullyPrivate(content: string): boolean;
+//# sourceMappingURL=privacy.d.ts.map

package/dist/services/privacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"privacy.d.ts","sourceRoot":"","sources":["../../src/services/privacy.ts"],"names":[],"mappings":"AAAA,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGvD"}

package/dist/services/privacy.js

@@ -0,0 +1,10 @@
+export function containsPrivateTag(content) {
+    return /<private>[\s\S]*?<\/private>/i.test(content);
+}
+export function stripPrivateContent(content) {
+    return content.replace(/<private>[\s\S]*?<\/private>/gi, "[REDACTED]");
+}
+export function isFullyPrivate(content) {
+    const stripped = stripPrivateContent(content).trim();
+    return stripped === "[REDACTED]" || stripped === "";
+}

package/dist/services/sqlite/connection-manager.d.ts

@@ -0,0 +1,10 @@
+import { Database } from "bun:sqlite";
+export declare class ConnectionManager {
+    private connections;
+    private initDatabase;
+    getConnection(dbPath: string): Database;
+    closeConnection(dbPath: string): void;
+    closeAll(): void;
+}
+export declare const connectionManager: ConnectionManager;
+//# sourceMappingURL=connection-manager.d.ts.map

package/dist/services/sqlite/connection-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-manager.d.ts","sourceRoot":"","sources":["../../../src/services/sqlite/connection-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAKtC,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAAoC;IAEvD,OAAO,CAAC,YAAY;IAUpB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ;IAkBvC,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IASrC,QAAQ,IAAI,IAAI;CAOjB;AAED,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}

package/dist/services/sqlite/connection-manager.js

@@ -0,0 +1,45 @@
+import { Database } from "bun:sqlite";
+import * as sqliteVec from "sqlite-vec";
+import { existsSync, mkdirSync } from "node:fs";
+import { log } from "../logger.js";
+export class ConnectionManager {
+    connections = new Map();
+    initDatabase(db) {
+        db.run("PRAGMA journal_mode = WAL");
+        db.run("PRAGMA synchronous = NORMAL");
+        db.run("PRAGMA cache_size = -64000");
+        db.run("PRAGMA temp_store = MEMORY");
+        db.run("PRAGMA foreign_keys = ON");
+        sqliteVec.load(db);
+    }
+    getConnection(dbPath) {
+        if (this.connections.has(dbPath)) {
+            return this.connections.get(dbPath);
+        }
+        const dir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        const db = new Database(dbPath);
+        this.initDatabase(db);
+        this.connections.set(dbPath, db);
+        log("SQLite connection opened", { path: dbPath });
+        return db;
+    }
+    closeConnection(dbPath) {
+        const db = this.connections.get(dbPath);
+        if (db) {
+            db.close();
+            this.connections.delete(dbPath);
+            log("SQLite connection closed", { path: dbPath });
+        }
+    }
+    closeAll() {
+        for (const [path, db] of this.connections) {
+            db.close();
+            log("SQLite connection closed", { path });
+        }
+        this.connections.clear();
+    }
+}
+export const connectionManager = new ConnectionManager();

package/dist/services/sqlite/shard-manager.d.ts

@@ -0,0 +1,20 @@
+import type { ShardInfo } from "./types.js";
+export declare class ShardManager {
+    private metadataDb;
+    private metadataPath;
+    constructor();
+    private initMetadataDb;
+    private getShardPath;
+    getActiveShard(scope: "user" | "project", scopeHash: string): ShardInfo | null;
+    getAllShards(scope: "user" | "project", scopeHash: string): ShardInfo[];
+    createShard(scope: "user" | "project", scopeHash: string, shardIndex: number): ShardInfo;
+    private initShardDb;
+    getWriteShard(scope: "user" | "project", scopeHash: string): ShardInfo;
+    private markShardReadOnly;
+    incrementVectorCount(shardId: number): void;
+    decrementVectorCount(shardId: number): void;
+    getShardByPath(dbPath: string): ShardInfo | null;
+    deleteShard(shardId: number): void;
+}
+export declare const shardManager: ShardManager;
+//# sourceMappingURL=shard-manager.d.ts.map

package/dist/services/sqlite/shard-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shard-manager.d.ts","sourceRoot":"","sources":["../../../src/services/sqlite/shard-manager.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAI5C,qBAAa,YAAY;IACvB,OAAO,CAAC,UAAU,CAAW;IAC7B,OAAO,CAAC,YAAY,CAAS;;IAQ7B,OAAO,CAAC,cAAc;IAqBtB,OAAO,CAAC,YAAY;IAKpB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAsB9E,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE;IAgCvE,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS;IA4BxF,OAAO,CAAC,WAAW;IAmDnB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS;IAetE,OAAO,CAAC,iBAAiB;IAQzB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO3C,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO3C,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAiBhD,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAsBnC;AAED,eAAO,MAAM,YAAY,cAAqB,CAAC"}