@sochdb/sochdb 0.4.0 → 0.4.1

package/dist/cjs/memory/extraction.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * Extraction Pipeline for Memory System
+ *
+ * Compiles LLM outputs into typed, validated facts (Entity, Relation, Assertion).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractionPipeline = void 0;
+const crypto_1 = require("crypto");
+/**
+ * Extraction Pipeline
+ */
+class ExtractionPipeline {
+    constructor(db, namespace, schema) {
+        this.db = db;
+        this.namespace = namespace;
+        this.schema = schema;
+        this.prefix = Buffer.from(`memory:${namespace}:`);
+    }
+    /**
+     * Create pipeline from database
+     */
+    static fromDatabase(db, namespace, schema) {
+        return new ExtractionPipeline(db, namespace, schema);
+    }
+    /**
+     * Extract entities and relations from text
+     */
+    async extract(text, extractor) {
+        const rawResult = await extractor(text);
+        const timestamp = Date.now();
+        // Normalize entities
+        const entities = (rawResult.entities || []).map(e => ({
+            id: this.generateEntityId(e.name, e.entity_type),
+            name: e.name,
+            entityType: e.entity_type,
+            properties: e.properties,
+            confidence: e.confidence || 1.0,
+            provenance: text.substring(0, 100),
+            timestamp,
+        }));
+        // Validate entities
+        if (this.schema?.entityTypes) {
+            const validTypes = new Set(this.schema.entityTypes);
+            const filteredEntities = entities.filter(e => validTypes.has(e.entityType));
+            if (filteredEntities.length < entities.length) {
+                console.warn(`Filtered ${entities.length - filteredEntities.length} entities with invalid types`);
+            }
+            entities.splice(0, entities.length, ...filteredEntities);
+        }
+        // Normalize relations
+        const relations = (rawResult.relations || []).map(r => ({
+            id: this.generateRelationId(r.from_entity, r.relation_type, r.to_entity),
+            fromEntity: r.from_entity,
+            relationType: r.relation_type,
+            toEntity: r.to_entity,
+            properties: r.properties,
+            confidence: r.confidence || 1.0,
+            provenance: text.substring(0, 100),
+            timestamp,
+        }));
+        // Validate relations
+        if (this.schema?.relationTypes) {
+            const validTypes = new Set(this.schema.relationTypes);
+            const filteredRelations = relations.filter(r => validTypes.has(r.relationType));
+            if (filteredRelations.length < relations.length) {
+                console.warn(`Filtered ${relations.length - filteredRelations.length} relations with invalid types`);
+            }
+            relations.splice(0, relations.length, ...filteredRelations);
+        }
+        // Normalize assertions
+        const assertions = (rawResult.assertions || []).map(a => ({
+            id: this.generateAssertionId(a.subject, a.predicate, a.object),
+            subject: a.subject,
+            predicate: a.predicate,
+            object: a.object,
+            confidence: a.confidence || 1.0,
+            provenance: text.substring(0, 100),
+            timestamp,
+        }));
+        // Apply min confidence filter
+        if (this.schema?.minConfidence) {
+            const minConf = this.schema.minConfidence;
+            const filterByConfidence = (items) => items.filter(item => (item.confidence || 0) >= minConf);
+            entities.splice(0, entities.length, ...filterByConfidence(entities));
+            relations.splice(0, relations.length, ...filterByConfidence(relations));
+            assertions.splice(0, assertions.length, ...filterByConfidence(assertions));
+        }
+        return { entities, relations, assertions };
+    }
+    /**
+     * Extract and immediately commit to database
+     */
+    async extractAndCommit(text, extractor) {
+        const result = await this.extract(text, extractor);
+        await this.commit(result);
+        return result;
+    }
+    /**
+     * Commit extraction result to database
+     */
+    async commit(result) {
+        // Store entities
+        for (const entity of result.entities) {
+            const key = Buffer.concat([this.prefix, Buffer.from(`entity:${entity.id}`)]);
+            await this.db.put(key, Buffer.from(JSON.stringify(entity)));
+        }
+        // Store relations
+        for (const relation of result.relations) {
+            const key = Buffer.concat([this.prefix, Buffer.from(`relation:${relation.id}`)]);
+            await this.db.put(key, Buffer.from(JSON.stringify(relation)));
+        }
+        // Store assertions
+        for (const assertion of result.assertions) {
+            const key = Buffer.concat([this.prefix, Buffer.from(`assertion:${assertion.id}`)]);
+            await this.db.put(key, Buffer.from(JSON.stringify(assertion)));
+        }
+    }
+    /**
+     * Get all entities
+     */
+    async getEntities() {
+        const entities = [];
+        const entityPrefix = Buffer.concat([this.prefix, Buffer.from('entity:')]);
+        for await (const [_, value] of this.db.scanPrefix(entityPrefix)) {
+            entities.push(JSON.parse(value.toString()));
+        }
+        return entities;
+    }
+    /**
+     * Get all relations
+     */
+    async getRelations() {
+        const relations = [];
+        const relationPrefix = Buffer.concat([this.prefix, Buffer.from('relation:')]);
+        for await (const [_, value] of this.db.scanPrefix(relationPrefix)) {
+            relations.push(JSON.parse(value.toString()));
+        }
+        return relations;
+    }
+    /**
+     * Get all assertions
+     */
+    async getAssertions() {
+        const assertions = [];
+        const assertionPrefix = Buffer.concat([this.prefix, Buffer.from('assertion:')]);
+        for await (const [_, value] of this.db.scanPrefix(assertionPrefix)) {
+            assertions.push(JSON.parse(value.toString()));
+        }
+        return assertions;
+    }
+    /**
+     * Generate deterministic entity ID
+     */
+    generateEntityId(name, entityType) {
+        return (0, crypto_1.createHash)('sha256')
+            .update(`${name}:${entityType}`)
+            .digest('hex')
+            .substring(0, 16);
+    }
+    /**
+     * Generate deterministic relation ID
+     */
+    generateRelationId(from, relationType, to) {
+        return (0, crypto_1.createHash)('sha256')
+            .update(`${from}:${relationType}:${to}`)
+            .digest('hex')
+            .substring(0, 16);
+    }
+    /**
+     * Generate deterministic assertion ID
+     */
+    generateAssertionId(subject, predicate, object) {
+        return (0, crypto_1.createHash)('sha256')
+            .update(`${subject}:${predicate}:${object}`)
+            .digest('hex')
+            .substring(0, 16);
+    }
+}
+exports.ExtractionPipeline = ExtractionPipeline;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extraction.js","sourceRoot":"","sources":["../../../src/memory/extraction.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Extraction Pipeline for Memory System\n * \n * Compiles LLM outputs into typed, validated facts (Entity, Relation, Assertion).\n */\n\nimport { EmbeddedDatabase } from '../embedded';\nimport {\n  Entity,\n  Relation,\n  Assertion,\n  ExtractionResult,\n  ExtractionSchema,\n} from './types';\nimport { createHash } from 'crypto';\n\n/**\n * Extractor function type - user provides this to call their LLM\n */\nexport type ExtractorFunction = (text: string) => Promise<{\n  entities?: Array<{ name: string; entity_type: string; properties?: Record<string, any>; confidence?: number }>;\n  relations?: Array<{ from_entity: string; relation_type: string; to_entity: string; properties?: Record<string, any>; confidence?: number }>;\n  assertions?: Array<{ subject: string; predicate: string; object: string; confidence?: number }>;\n}>;\n\n/**\n * Extraction Pipeline\n */\nexport class ExtractionPipeline {\n  private db: EmbeddedDatabase;\n  private namespace: string;\n  private schema?: ExtractionSchema;\n  private prefix: Buffer;\n\n  constructor(db: EmbeddedDatabase, namespace: string, schema?: ExtractionSchema) {\n    this.db = db;\n    this.namespace = namespace;\n    this.schema = schema;\n    this.prefix = Buffer.from(`memory:${namespace}:`);\n  }\n\n  /**\n   * Create pipeline from database\n   */\n  static fromDatabase(db: EmbeddedDatabase, namespace: string, schema?: ExtractionSchema): ExtractionPipeline {\n    return new ExtractionPipeline(db, namespace, schema);\n  }\n\n  /**\n   * Extract entities and relations from text\n   */\n  async extract(text: string, extractor: ExtractorFunction): Promise<ExtractionResult> {\n    const rawResult = await extractor(text);\n    const timestamp = Date.now();\n\n    // Normalize entities\n    const entities: Entity[] = (rawResult.entities || []).map(e => ({\n      id: this.generateEntityId(e.name, e.entity_type),\n      name: e.name,\n      entityType: e.entity_type,\n      properties: e.properties,\n      confidence: e.confidence || 1.0,\n      provenance: text.substring(0, 100),\n      timestamp,\n    }));\n\n    // Validate entities\n    if (this.schema?.entityTypes) {\n      const validTypes = new Set(this.schema.entityTypes);\n      const filteredEntities = entities.filter(e => validTypes.has(e.entityType));\n      if (filteredEntities.length < entities.length) {\n        console.warn(`Filtered ${entities.length - filteredEntities.length} entities with invalid types`);\n      }\n      entities.splice(0, entities.length, ...filteredEntities);\n    }\n\n    // Normalize relations\n    const relations: Relation[] = (rawResult.relations || []).map(r => ({\n      id: this.generateRelationId(r.from_entity, r.relation_type, r.to_entity),\n      fromEntity: r.from_entity,\n      relationType: r.relation_type,\n      toEntity: r.to_entity,\n      properties: r.properties,\n      confidence: r.confidence || 1.0,\n      provenance: text.substring(0, 100),\n      timestamp,\n    }));\n\n    // Validate relations\n    if (this.schema?.relationTypes) {\n      const validTypes = new Set(this.schema.relationTypes);\n      const filteredRelations = relations.filter(r => validTypes.has(r.relationType));\n      if (filteredRelations.length < relations.length) {\n        console.warn(`Filtered ${relations.length - filteredRelations.length} relations with invalid types`);\n      }\n      relations.splice(0, relations.length, ...filteredRelations);\n    }\n\n    // Normalize assertions\n    const assertions: Assertion[] = (rawResult.assertions || []).map(a => ({\n      id: this.generateAssertionId(a.subject, a.predicate, a.object),\n      subject: a.subject,\n      predicate: a.predicate,\n      object: a.object,\n      confidence: a.confidence || 1.0,\n      provenance: text.substring(0, 100),\n      timestamp,\n    }));\n\n    // Apply min confidence filter\n    if (this.schema?.minConfidence) {\n      const minConf = this.schema.minConfidence;\n      const filterByConfidence = <T extends { confidence?: number }>(items: T[]): T[] =>\n        items.filter(item => (item.confidence || 0) >= minConf);\n\n      entities.splice(0, entities.length, ...filterByConfidence(entities));\n      relations.splice(0, relations.length, ...filterByConfidence(relations));\n      assertions.splice(0, assertions.length, ...filterByConfidence(assertions));\n    }\n\n    return { entities, relations, assertions };\n  }\n\n  /**\n   * Extract and immediately commit to database\n   */\n  async extractAndCommit(text: string, extractor: ExtractorFunction): Promise<ExtractionResult> {\n    const result = await this.extract(text, extractor);\n    await this.commit(result);\n    return result;\n  }\n\n  /**\n   * Commit extraction result to database\n   */\n  async commit(result: ExtractionResult): Promise<void> {\n    // Store entities\n    for (const entity of result.entities) {\n      const key = Buffer.concat([this.prefix, Buffer.from(`entity:${entity.id}`)]);\n      await this.db.put(key, Buffer.from(JSON.stringify(entity)));\n    }\n\n    // Store relations\n    for (const relation of result.relations) {\n      const key = Buffer.concat([this.prefix, Buffer.from(`relation:${relation.id}`)]);\n      await this.db.put(key, Buffer.from(JSON.stringify(relation)));\n    }\n\n    // Store assertions\n    for (const assertion of result.assertions) {\n      const key = Buffer.concat([this.prefix, Buffer.from(`assertion:${assertion.id}`)]);\n      await this.db.put(key, Buffer.from(JSON.stringify(assertion)));\n    }\n  }\n\n  /**\n   * Get all entities\n   */\n  async getEntities(): Promise<Entity[]> {\n    const entities: Entity[] = [];\n    const entityPrefix = Buffer.concat([this.prefix, Buffer.from('entity:')]);\n\n    for await (const [_, value] of this.db.scanPrefix(entityPrefix)) {\n      entities.push(JSON.parse(value.toString()));\n    }\n\n    return entities;\n  }\n\n  /**\n   * Get all relations\n   */\n  async getRelations(): Promise<Relation[]> {\n    const relations: Relation[] = [];\n    const relationPrefix = Buffer.concat([this.prefix, Buffer.from('relation:')]);\n\n    for await (const [_, value] of this.db.scanPrefix(relationPrefix)) {\n      relations.push(JSON.parse(value.toString()));\n    }\n\n    return relations;\n  }\n\n  /**\n   * Get all assertions\n   */\n  async getAssertions(): Promise<Assertion[]> {\n    const assertions: Assertion[] = [];\n    const assertionPrefix = Buffer.concat([this.prefix, Buffer.from('assertion:')]);\n\n    for await (const [_, value] of this.db.scanPrefix(assertionPrefix)) {\n      assertions.push(JSON.parse(value.toString()));\n    }\n\n    return assertions;\n  }\n\n  /**\n   * Generate deterministic entity ID\n   */\n  private generateEntityId(name: string, entityType: string): string {\n    return createHash('sha256')\n      .update(`${name}:${entityType}`)\n      .digest('hex')\n      .substring(0, 16);\n  }\n\n  /**\n   * Generate deterministic relation ID\n   */\n  private generateRelationId(from: string, relationType: string, to: string): string {\n    return createHash('sha256')\n      .update(`${from}:${relationType}:${to}`)\n      .digest('hex')\n      .substring(0, 16);\n  }\n\n  /**\n   * Generate deterministic assertion ID\n   */\n  private generateAssertionId(subject: string, predicate: string, object: string): string {\n    return createHash('sha256')\n      .update(`${subject}:${predicate}:${object}`)\n      .digest('hex')\n      .substring(0, 16);\n  }\n}\n"]}

package/dist/cjs/memory/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Memory System - Main Export
+ *
+ * LLM-native memory system with extraction, consolidation, and retrieval.
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./extraction"), exports);
+__exportStar(require("./consolidation"), exports);
+__exportStar(require("./retrieval"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtb3J5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7OztHQUlHOzs7Ozs7Ozs7Ozs7Ozs7O0FBRUgsMENBQXdCO0FBQ3hCLCtDQUE2QjtBQUM3QixrREFBZ0M7QUFDaEMsOENBQTRCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBNZW1vcnkgU3lzdGVtIC0gTWFpbiBFeHBvcnRcbiAqIFxuICogTExNLW5hdGl2ZSBtZW1vcnkgc3lzdGVtIHdpdGggZXh0cmFjdGlvbiwgY29uc29saWRhdGlvbiwgYW5kIHJldHJpZXZhbC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4vZXh0cmFjdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL2NvbnNvbGlkYXRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9yZXRyaWV2YWwnO1xuIl19

package/dist/cjs/memory/retrieval.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * Hybrid Retriever for Memory System
+ *
+ * Combines vector and keyword search with RRF (Reciprocal Rank Fusion).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridRetriever = void 0;
+/**
+ * Simple BM25 scorer for keyword matching
+ */
+class BM25Scorer {
+    constructor() {
+        this.k1 = 1.5;
+        this.b = 0.75;
+        this.avgDocLength = 0;
+        this.docLengths = new Map();
+        this.termFreqs = new Map();
+        this.docFreqs = new Map();
+        this.numDocs = 0;
+    }
+    /**
+     * Index a document
+     */
+    indexDocument(docId, text) {
+        const terms = this.tokenize(text);
+        const termCounts = new Map();
+        for (const term of terms) {
+            termCounts.set(term, (termCounts.get(term) || 0) + 1);
+        }
+        this.docLengths.set(docId, terms.length);
+        this.termFreqs.set(docId, termCounts);
+        for (const term of termCounts.keys()) {
+            this.docFreqs.set(term, (this.docFreqs.get(term) || 0) + 1);
+        }
+        this.numDocs++;
+        this.updateAvgDocLength();
+    }
+    /**
+     * Score a query against a document
+     */
+    score(docId, queryTerms) {
+        const termCounts = this.termFreqs.get(docId);
+        if (!termCounts)
+            return 0;
+        const docLength = this.docLengths.get(docId) || 0;
+        let score = 0;
+        for (const term of queryTerms) {
+            const tf = termCounts.get(term) || 0;
+            const df = this.docFreqs.get(term) || 0;
+            if (tf === 0)
+                continue;
+            const idf = Math.log((this.numDocs - df + 0.5) / (df + 0.5) + 1);
+            const norm = tf / (tf + this.k1 * (1 - this.b + this.b * (docLength / this.avgDocLength)));
+            score += idf * norm;
+        }
+        return score;
+    }
+    /**
+     * Tokenize text into terms
+     */
+    tokenize(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter(t => t.length > 0);
+    }
+    /**
+     * Update average document length
+     */
+    updateAvgDocLength() {
+        const totalLength = Array.from(this.docLengths.values()).reduce((a, b) => a + b, 0);
+        this.avgDocLength = totalLength / this.numDocs;
+    }
+}
+/**
+ * Cosine similarity for vector search
+ */
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length)
+        return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    if (normA === 0 || normB === 0)
+        return 0;
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+/**
+ * Hybrid Retriever with RRF fusion
+ */
+class HybridRetriever {
+    constructor(db, namespace, collection, config) {
+        this.indexed = false;
+        this.db = db;
+        this.namespace = namespace;
+        this.collection = collection;
+        this.config = {
+            k: config?.k || 10,
+            alpha: config?.alpha !== undefined ? config.alpha : 0.5,
+            enableRerank: config?.enableRerank || false,
+            rerankK: config?.rerankK || 100,
+        };
+        this.prefix = Buffer.from(`retrieval:${namespace}:${collection}:`);
+        this.bm25 = new BM25Scorer();
+    }
+    /**
+     * Create retriever from database
+     */
+    static fromDatabase(db, namespace, collection, config) {
+        return new HybridRetriever(db, namespace, collection, config);
+    }
+    /**
+     * Index documents for retrieval
+     */
+    async indexDocuments(documents) {
+        for (const doc of documents) {
+            const key = Buffer.concat([this.prefix, Buffer.from(doc.id)]);
+            await this.db.put(key, Buffer.from(JSON.stringify({
+                id: doc.id,
+                content: doc.content,
+                embedding: doc.embedding,
+                metadata: doc.metadata,
+            })));
+            // Index for BM25
+            this.bm25.indexDocument(doc.id, doc.content);
+        }
+        this.indexed = true;
+    }
+    /**
+     * Retrieve documents with hybrid search
+     */
+    async retrieve(queryText, queryVector, allowed, k) {
+        const startTime = Date.now();
+        const targetK = k || this.config.k;
+        // Get all documents
+        const documents = [];
+        for await (const [_, value] of this.db.scanPrefix(this.prefix)) {
+            const doc = JSON.parse(value.toString());
+            // Apply pre-filtering with AllowedSet
+            if (allowed.contains(doc.id, doc.metadata)) {
+                documents.push(doc);
+            }
+        }
+        // Vector search scores
+        const vectorScores = new Map();
+        documents
+            .map(doc => ({
+            id: doc.id,
+            score: cosineSimilarity(queryVector, doc.embedding),
+        }))
+            .sort((a, b) => b.score - a.score)
+            .forEach((item, rank) => {
+            vectorScores.set(item.id, { score: item.score, rank });
+        });
+        // Keyword search scores (BM25)
+        const queryTerms = queryText
+            .toLowerCase()
+            .replace(/[^\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter(t => t.length > 0);
+        const keywordScores = new Map();
+        documents
+            .map(doc => ({
+            id: doc.id,
+            score: this.bm25.score(doc.id, queryTerms),
+        }))
+            .sort((a, b) => b.score - a.score)
+            .forEach((item, rank) => {
+            keywordScores.set(item.id, { score: item.score, rank });
+        });
+        // RRF (Reciprocal Rank Fusion)
+        const k_rrf = 60; // RRF constant
+        const alpha = this.config.alpha;
+        const fusedScores = documents.map(doc => {
+            const vectorData = vectorScores.get(doc.id);
+            const keywordData = keywordScores.get(doc.id);
+            const vectorScore = vectorData ? 1 / (k_rrf + vectorData.rank) : 0;
+            const keywordScore = keywordData ? 1 / (k_rrf + keywordData.rank) : 0;
+            // Weighted combination
+            const finalScore = alpha * vectorScore + (1 - alpha) * keywordScore;
+            return {
+                id: doc.id,
+                score: finalScore,
+                content: doc.content,
+                metadata: doc.metadata,
+                vectorRank: vectorData?.rank,
+                keywordRank: keywordData?.rank,
+            };
+        });
+        // Sort by fused score and take top k
+        fusedScores.sort((a, b) => b.score - a.score);
+        const results = fusedScores.slice(0, targetK);
+        return {
+            results,
+            queryTime: Date.now() - startTime,
+            totalResults: documents.length,
+        };
+    }
+    /**
+     * Explain ranking for a specific document
+     */
+    async explain(queryText, queryVector, docId) {
+        // Simplified version - full implementation would require re-running retrieval
+        const key = Buffer.concat([this.prefix, Buffer.from(docId)]);
+        const value = await this.db.get(key);
+        if (!value) {
+            return {};
+        }
+        const doc = JSON.parse(value.toString());
+        const vectorScore = cosineSimilarity(queryVector, doc.embedding);
+        const queryTerms = queryText
+            .toLowerCase()
+            .replace(/[^\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter(t => t.length > 0);
+        const keywordScore = this.bm25.score(docId, queryTerms);
+        return {
+            vectorRank: undefined, // Would need full ranking
+            keywordRank: undefined,
+            expectedRrfScore: vectorScore + keywordScore, // Simplified
+        };
+    }
+}
+exports.HybridRetriever = HybridRetriever;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retrieval.js","sourceRoot":"","sources":["../../../src/memory/retrieval.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Hybrid Retriever for Memory System\n * \n * Combines vector and keyword search with RRF (Reciprocal Rank Fusion).\n */\n\nimport { EmbeddedDatabase } from '../embedded';\nimport {\n  AllowedSet,\n  RetrievalConfig,\n  RetrievalResponse,\n  RetrievalResult,\n} from './types';\n\n/**\n * Simple BM25 scorer for keyword matching\n */\nclass BM25Scorer {\n  private k1 = 1.5;\n  private b = 0.75;\n  private avgDocLength: number;\n  private docLengths: Map<string, number>;\n  private termFreqs: Map<string, Map<string, number>>;\n  private docFreqs: Map<string, number>;\n  private numDocs: number;\n\n  constructor() {\n    this.avgDocLength = 0;\n    this.docLengths = new Map();\n    this.termFreqs = new Map();\n    this.docFreqs = new Map();\n    this.numDocs = 0;\n  }\n\n  /**\n   * Index a document\n   */\n  indexDocument(docId: string, text: string): void {\n    const terms = this.tokenize(text);\n    const termCounts = new Map<string, number>();\n\n    for (const term of terms) {\n      termCounts.set(term, (termCounts.get(term) || 0) + 1);\n    }\n\n    this.docLengths.set(docId, terms.length);\n    this.termFreqs.set(docId, termCounts);\n\n    for (const term of termCounts.keys()) {\n      this.docFreqs.set(term, (this.docFreqs.get(term) || 0) + 1);\n    }\n\n    this.numDocs++;\n    this.updateAvgDocLength();\n  }\n\n  /**\n   * Score a query against a document\n   */\n  score(docId: string, queryTerms: string[]): number {\n    const termCounts = this.termFreqs.get(docId);\n    if (!termCounts) return 0;\n\n    const docLength = this.docLengths.get(docId) || 0;\n    let score = 0;\n\n    for (const term of queryTerms) {\n      const tf = termCounts.get(term) || 0;\n      const df = this.docFreqs.get(term) || 0;\n      \n      if (tf === 0) continue;\n\n      const idf = Math.log((this.numDocs - df + 0.5) / (df + 0.5) + 1);\n      const norm = tf / (tf + this.k1 * (1 - this.b + this.b * (docLength / this.avgDocLength)));\n      \n      score += idf * norm;\n    }\n\n    return score;\n  }\n\n  /**\n   * Tokenize text into terms\n   */\n  private tokenize(text: string): string[] {\n    return text\n      .toLowerCase()\n      .replace(/[^\\w\\s]/g, ' ')\n      .split(/\\s+/)\n      .filter(t => t.length > 0);\n  }\n\n  /**\n   * Update average document length\n   */\n  private updateAvgDocLength(): void {\n    const totalLength = Array.from(this.docLengths.values()).reduce((a, b) => a + b, 0);\n    this.avgDocLength = totalLength / this.numDocs;\n  }\n}\n\n/**\n * Cosine similarity for vector search\n */\nfunction cosineSimilarity(a: number[], b: number[]): number {\n  if (a.length !== b.length) return 0;\n\n  let dotProduct = 0;\n  let normA = 0;\n  let normB = 0;\n\n  for (let i = 0; i < a.length; i++) {\n    dotProduct += a[i] * b[i];\n    normA += a[i] * a[i];\n    normB += b[i] * b[i];\n  }\n\n  if (normA === 0 || normB === 0) return 0;\n  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));\n}\n\n/**\n * Hybrid Retriever with RRF fusion\n */\nexport class HybridRetriever {\n  private db: EmbeddedDatabase;\n  private namespace: string;\n  private collection: string;\n  private config: RetrievalConfig;\n  private prefix: Buffer;\n  private bm25: BM25Scorer;\n  private indexed: boolean = false;\n\n  constructor(\n    db: EmbeddedDatabase,\n    namespace: string,\n    collection: string,\n    config?: RetrievalConfig\n  ) {\n    this.db = db;\n    this.namespace = namespace;\n    this.collection = collection;\n    this.config = {\n      k: config?.k || 10,\n      alpha: config?.alpha !== undefined ? config.alpha : 0.5,\n      enableRerank: config?.enableRerank || false,\n      rerankK: config?.rerankK || 100,\n    };\n    this.prefix = Buffer.from(`retrieval:${namespace}:${collection}:`);\n    this.bm25 = new BM25Scorer();\n  }\n\n  /**\n   * Create retriever from database\n   */\n  static fromDatabase(\n    db: EmbeddedDatabase,\n    namespace: string,\n    collection: string,\n    config?: RetrievalConfig\n  ): HybridRetriever {\n    return new HybridRetriever(db, namespace, collection, config);\n  }\n\n  /**\n   * Index documents for retrieval\n   */\n  async indexDocuments(documents: Array<{ id: string; content: string; embedding: number[]; metadata?: Record<string, any> }>): Promise<void> {\n    for (const doc of documents) {\n      const key = Buffer.concat([this.prefix, Buffer.from(doc.id)]);\n      await this.db.put(key, Buffer.from(JSON.stringify({\n        id: doc.id,\n        content: doc.content,\n        embedding: doc.embedding,\n        metadata: doc.metadata,\n      })));\n\n      // Index for BM25\n      this.bm25.indexDocument(doc.id, doc.content);\n    }\n\n    this.indexed = true;\n  }\n\n  /**\n   * Retrieve documents with hybrid search\n   */\n  async retrieve(\n    queryText: string,\n    queryVector: number[],\n    allowed: AllowedSet,\n    k?: number\n  ): Promise<RetrievalResponse> {\n    const startTime = Date.now();\n    const targetK = k || this.config.k!;\n\n    // Get all documents\n    const documents: Array<{\n      id: string;\n      content: string;\n      embedding: number[];\n      metadata?: Record<string, any>;\n    }> = [];\n\n    for await (const [_, value] of this.db.scanPrefix(this.prefix)) {\n      const doc = JSON.parse(value.toString());\n      \n      // Apply pre-filtering with AllowedSet\n      if (allowed.contains(doc.id, doc.metadata)) {\n        documents.push(doc);\n      }\n    }\n\n    // Vector search scores\n    const vectorScores = new Map<string, { score: number; rank: number }>();\n    documents\n      .map(doc => ({\n        id: doc.id,\n        score: cosineSimilarity(queryVector, doc.embedding),\n      }))\n      .sort((a, b) => b.score - a.score)\n      .forEach((item, rank) => {\n        vectorScores.set(item.id, { score: item.score, rank });\n      });\n\n    // Keyword search scores (BM25)\n    const queryTerms = queryText\n      .toLowerCase()\n      .replace(/[^\\w\\s]/g, ' ')\n      .split(/\\s+/)\n      .filter(t => t.length > 0);\n\n    const keywordScores = new Map<string, { score: number; rank: number }>();\n    documents\n      .map(doc => ({\n        id: doc.id,\n        score: this.bm25.score(doc.id, queryTerms),\n      }))\n      .sort((a, b) => b.score - a.score)\n      .forEach((item, rank) => {\n        keywordScores.set(item.id, { score: item.score, rank });\n      });\n\n    // RRF (Reciprocal Rank Fusion)\n    const k_rrf = 60; // RRF constant\n    const alpha = this.config.alpha!;\n    \n    const fusedScores = documents.map(doc => {\n      const vectorData = vectorScores.get(doc.id);\n      const keywordData = keywordScores.get(doc.id);\n      \n      const vectorScore = vectorData ? 1 / (k_rrf + vectorData.rank) : 0;\n      const keywordScore = keywordData ? 1 / (k_rrf + keywordData.rank) : 0;\n      \n      // Weighted combination\n      const finalScore = alpha * vectorScore + (1 - alpha) * keywordScore;\n\n      return {\n        id: doc.id,\n        score: finalScore,\n        content: doc.content,\n        metadata: doc.metadata,\n        vectorRank: vectorData?.rank,\n        keywordRank: keywordData?.rank,\n      };\n    });\n\n    // Sort by fused score and take top k\n    fusedScores.sort((a, b) => b.score - a.score);\n    const results = fusedScores.slice(0, targetK);\n\n    return {\n      results,\n      queryTime: Date.now() - startTime,\n      totalResults: documents.length,\n    };\n  }\n\n  /**\n   * Explain ranking for a specific document\n   */\n  async explain(\n    queryText: string,\n    queryVector: number[],\n    docId: string\n  ): Promise<{ vectorRank?: number; keywordRank?: number; expectedRrfScore?: number }> {\n    // Simplified version - full implementation would require re-running retrieval\n    const key = Buffer.concat([this.prefix, Buffer.from(docId)]);\n    const value = await this.db.get(key);\n    \n    if (!value) {\n      return {};\n    }\n\n    const doc = JSON.parse(value.toString());\n    \n    const vectorScore = cosineSimilarity(queryVector, doc.embedding);\n    const queryTerms = queryText\n      .toLowerCase()\n      .replace(/[^\\w\\s]/g, ' ')\n      .split(/\\s+/)\n      .filter(t => t.length > 0);\n    const keywordScore = this.bm25.score(docId, queryTerms);\n\n    return {\n      vectorRank: undefined, // Would need full ranking\n      keywordRank: undefined,\n      expectedRrfScore: vectorScore + keywordScore, // Simplified\n    };\n  }\n}\n"]}

package/dist/cjs/memory/types.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Memory System Core Types
+ *
+ * Type definitions for LLM-native memory system with extraction,
+ * consolidation, and retrieval capabilities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamespacePolicy = exports.AllowedSet = void 0;
+/**
+ * AllowedSet for pre-filtering
+ */
+class AllowedSet {
+    static fromIds(ids) {
+        return new IdsAllowedSet(new Set(ids));
+    }
+    static fromNamespace(namespace) {
+        return new NamespaceAllowedSet(namespace);
+    }
+    static fromFilter(filterFn) {
+        return new FilterAllowedSet(filterFn);
+    }
+    static allowAll() {
+        return new AllAllowedSet();
+    }
+}
+exports.AllowedSet = AllowedSet;
+class IdsAllowedSet extends AllowedSet {
+    constructor(ids) {
+        super();
+        this.ids = ids;
+    }
+    contains(id) {
+        return this.ids.has(id);
+    }
+}
+class NamespaceAllowedSet extends AllowedSet {
+    constructor(namespace) {
+        super();
+        this.namespace = namespace;
+    }
+    contains(id) {
+        return id.startsWith(`${this.namespace}_`) || id.startsWith(`${this.namespace}:`);
+    }
+}
+class FilterAllowedSet extends AllowedSet {
+    constructor(filterFn) {
+        super();
+        this.filterFn = filterFn;
+    }
+    contains(id, metadata) {
+        return this.filterFn(id, metadata);
+    }
+}
+class AllAllowedSet extends AllowedSet {
+    contains() {
+        return true;
+    }
+}
+/**
+ * Namespace policy
+ */
+var NamespacePolicy;
+(function (NamespacePolicy) {
+    NamespacePolicy["STRICT"] = "strict";
+    NamespacePolicy["EXPLICIT"] = "explicit";
+    NamespacePolicy["PERMISSIVE"] = "permissive";
+})(NamespacePolicy || (exports.NamespacePolicy = NamespacePolicy = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtb3J5L3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7R0FLRzs7O0FBNEhIOztHQUVHO0FBQ0gsTUFBc0IsVUFBVTtJQUc5QixNQUFNLENBQUMsT0FBTyxDQUFDLEdBQWE7UUFDMUIsT0FBTyxJQUFJLGFBQWEsQ0FBQyxJQUFJLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO0lBQ3pDLENBQUM7SUFFRCxNQUFNLENBQUMsYUFBYSxDQUFDLFNBQWlCO1FBQ3BDLE9BQU8sSUFBSSxtQkFBbUIsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUM1QyxDQUFDO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxRQUFpRTtRQUNqRixPQUFPLElBQUksZ0JBQWdCLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDeEMsQ0FBQztJQUVELE1BQU0sQ0FBQyxRQUFRO1FBQ2IsT0FBTyxJQUFJLGFBQWEsRUFBRSxDQUFDO0lBQzdCLENBQUM7Q0FDRjtBQWxCRCxnQ0FrQkM7QUFFRCxNQUFNLGFBQWMsU0FBUSxVQUFVO0lBQ3BDLFlBQW9CLEdBQWdCO1FBQ2xDLEtBQUssRUFBRSxDQUFDO1FBRFUsUUFBRyxHQUFILEdBQUcsQ0FBYTtJQUVwQyxDQUFDO0lBRUQsUUFBUSxDQUFDLEVBQVU7UUFDakIsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUMxQixDQUFDO0NBQ0Y7QUFFRCxNQUFNLG1CQUFvQixTQUFRLFVBQVU7SUFDMUMsWUFBb0IsU0FBaUI7UUFDbkMsS0FBSyxFQUFFLENBQUM7UUFEVSxjQUFTLEdBQVQsU0FBUyxDQUFRO0lBRXJDLENBQUM7SUFFRCxRQUFRLENBQUMsRUFBVTtRQUNqQixPQUFPLEVBQUUsQ0FBQyxVQUFVLENBQUMsR0FBRyxJQUFJLENBQUMsU0FBUyxHQUFHLENBQUMsSUFBSSxFQUFFLENBQUMsVUFBVSxDQUFDLEdBQUcsSUFBSSxDQUFDLFNBQVMsR0FBRyxDQUFDLENBQUM7SUFDcEYsQ0FBQztDQUNGO0FBRUQsTUFBTSxnQkFBaUIsU0FBUSxVQUFVO0lBQ3ZDLFlBQW9CLFFBQWlFO1FBQ25GLEtBQUssRUFBRSxDQUFDO1FBRFUsYUFBUSxHQUFSLFFBQVEsQ0FBeUQ7SUFFckYsQ0FBQztJQUVELFFBQVEsQ0FBQyxFQUFVLEVBQUUsUUFBOEI7UUFDakQsT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFDLEVBQUUsRUFBRSxRQUFRLENBQUMsQ0FBQztJQUNyQyxDQUFDO0NBQ0Y7QUFFRCxNQUFNLGFBQWMsU0FBUSxVQUFVO0lBQ3BDLFFBQVE7UUFDTixPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7Q0FDRjtBQUVEOztHQUVHO0FBQ0gsSUFBWSxlQUlYO0FBSkQsV0FBWSxlQUFlO0lBQ3pCLG9DQUFpQixDQUFBO0lBQ2pCLHdDQUFxQixDQUFBO0lBQ3JCLDRDQUF5QixDQUFBO0FBQzNCLENBQUMsRUFKVyxlQUFlLCtCQUFmLGVBQWUsUUFJMUIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIE1lbW9yeSBTeXN0ZW0gQ29yZSBUeXBlc1xuICogXG4gKiBUeXBlIGRlZmluaXRpb25zIGZvciBMTE0tbmF0aXZlIG1lbW9yeSBzeXN0ZW0gd2l0aCBleHRyYWN0aW9uLFxuICogY29uc29saWRhdGlvbiwgYW5kIHJldHJpZXZhbCBjYXBhYmlsaXRpZXMuXG4gKi9cblxuLyoqXG4gKiBFbnRpdHkgZXh0cmFjdGVkIGZyb20gdGV4dFxuICovXG5leHBvcnQgaW50ZXJmYWNlIEVudGl0eSB7XG4gIGlkPzogc3RyaW5nO1xuICBuYW1lOiBzdHJpbmc7XG4gIGVudGl0eVR5cGU6IHN0cmluZztcbiAgcHJvcGVydGllcz86IFJlY29yZDxzdHJpbmcsIGFueT47XG4gIGNvbmZpZGVuY2U/OiBudW1iZXI7XG4gIHByb3ZlbmFuY2U/OiBzdHJpbmc7XG4gIHRpbWVzdGFtcD86IG51bWJlcjtcbn1cblxuLyoqXG4gKiBSZWxhdGlvbiBiZXR3ZWVuIHR3byBlbnRpdGllc1xuICovXG5leHBvcnQgaW50ZXJmYWNlIFJlbGF0aW9uIHtcbiAgaWQ/OiBzdHJpbmc7XG4gIGZyb21FbnRpdHk6IHN0cmluZztcbiAgcmVsYXRpb25UeXBlOiBzdHJpbmc7XG4gIHRvRW50aXR5OiBzdHJpbmc7XG4gIHByb3BlcnRpZXM/OiBSZWNvcmQ8c3RyaW5nLCBhbnk+O1xuICBjb25maWRlbmNlPzogbnVtYmVyO1xuICBwcm92ZW5hbmNlPzogc3RyaW5nO1xuICB0aW1lc3RhbXA/OiBudW1iZXI7XG59XG5cbi8qKlxuICogQXNzZXJ0aW9uIChzdWJqZWN0LXByZWRpY2F0ZS1vYmplY3QgdHJpcGxlKVxuICovXG5leHBvcnQgaW50ZXJmYWNlIEFzc2VydGlvbiB7XG4gIGlkPzogc3RyaW5nO1xuICBzdWJqZWN0OiBzdHJpbmc7XG4gIHByZWRpY2F0ZTogc3RyaW5nO1xuICBvYmplY3Q6IHN0cmluZztcbiAgY29uZmlkZW5jZT86IG51bWJlcjtcbiAgcHJvdmVuYW5jZT86IHN0cmluZztcbiAgdGltZXN0YW1wPzogbnVtYmVyO1xufVxuXG4vKipcbiAqIFJhdyBhc3NlcnRpb24gZm9yIGNvbnNvbGlkYXRpb25cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBSYXdBc3NlcnRpb24ge1xuICBpZD86IHN0cmluZztcbiAgZmFjdDogUmVjb3JkPHN0cmluZywgYW55PjtcbiAgc291cmNlOiBzdHJpbmc7XG4gIGNvbmZpZGVuY2U6IG51bWJlcjtcbiAgdGltZXN0YW1wPzogbnVtYmVyO1xufVxuXG4vKipcbiAqIENhbm9uaWNhbCBmYWN0IGFmdGVyIGNvbnNvbGlkYXRpb25cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBDYW5vbmljYWxGYWN0IHtcbiAgaWQ6IHN0cmluZztcbiAgbWVyZ2VkRmFjdDogUmVjb3JkPHN0cmluZywgYW55PjtcbiAgY29uZmlkZW5jZTogbnVtYmVyO1xuICBzb3VyY2VzOiBzdHJpbmdbXTtcbiAgdmFsaWRGcm9tOiBudW1iZXI7XG4gIHZhbGlkVW50aWw/OiBudW1iZXI7XG59XG5cbi8qKlxuICogRXh0cmFjdGlvbiByZXN1bHQgZnJvbSBMTE1cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBFeHRyYWN0aW9uUmVzdWx0IHtcbiAgZW50aXRpZXM6IEVudGl0eVtdO1xuICByZWxhdGlvbnM6IFJlbGF0aW9uW107XG4gIGFzc2VydGlvbnM6IEFzc2VydGlvbltdO1xufVxuXG4vKipcbiAqIEV4dHJhY3Rpb24gc2NoZW1hIGZvciB2YWxpZGF0aW9uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRXh0cmFjdGlvblNjaGVtYSB7XG4gIGVudGl0eVR5cGVzPzogc3RyaW5nW107XG4gIHJlbGF0aW9uVHlwZXM/OiBzdHJpbmdbXTtcbiAgbWluQ29uZmlkZW5jZT86IG51bWJlcjtcbiAgcmVxdWlyZVByb3ZlbmFuY2U/OiBib29sZWFuO1xufVxuXG4vKipcbiAqIENvbnNvbGlkYXRpb24gY29uZmlndXJhdGlvblxuICovXG5leHBvcnQgaW50ZXJmYWNlIENvbnNvbGlkYXRpb25Db25maWcge1xuICBzaW1pbGFyaXR5VGhyZXNob2xkPzogbnVtYmVyO1xuICB1c2VUZW1wb3JhbFVwZGF0ZXM/OiBib29sZWFuO1xuICBtYXhDb25mbGljdEFnZT86IG51bWJlcjsgLy8gc2Vjb25kc1xufVxuXG4vKipcbiAqIFJldHJpZXZhbCBjb25maWd1cmF0aW9uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUmV0cmlldmFsQ29uZmlnIHtcbiAgaz86IG51bWJlcjtcbiAgYWxwaGE/OiBudW1iZXI7IC8vIDA9a2V5d29yZCBvbmx5LCAxPXZlY3RvciBvbmx5LCAwLjU9YmFsYW5jZWRcbiAgZW5hYmxlUmVyYW5rPzogYm9vbGVhbjtcbiAgcmVyYW5rSz86IG51bWJlcjtcbn1cblxuLyoqXG4gKiBSZXRyaWV2YWwgcmVzdWx0XG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUmV0cmlldmFsUmVzdWx0IHtcbiAgaWQ6IHN0cmluZztcbiAgc2NvcmU6IG51bWJlcjtcbiAgY29udGVudDogc3RyaW5nO1xuICBtZXRhZGF0YT86IFJlY29yZDxzdHJpbmcsIGFueT47XG4gIHZlY3RvclJhbms/OiBudW1iZXI7XG4gIGtleXdvcmRSYW5rPzogbnVtYmVyO1xufVxuXG4vKipcbiAqIFJldHJpZXZhbCByZXNwb25zZVxuICovXG5leHBvcnQgaW50ZXJmYWNlIFJldHJpZXZhbFJlc3BvbnNlIHtcbiAgcmVzdWx0czogUmV0cmlldmFsUmVzdWx0W107XG4gIHF1ZXJ5VGltZTogbnVtYmVyO1xuICB0b3RhbFJlc3VsdHM6IG51bWJlcjtcbn1cblxuLyoqXG4gKiBBbGxvd2VkU2V0IGZvciBwcmUtZmlsdGVyaW5nXG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBBbGxvd2VkU2V0IHtcbiAgYWJzdHJhY3QgY29udGFpbnMoaWQ6IHN0cmluZywgbWV0YWRhdGE/OiBSZWNvcmQ8c3RyaW5nLCBhbnk+KTogYm9vbGVhbjtcblxuICBzdGF0aWMgZnJvbUlkcyhpZHM6IHN0cmluZ1tdKTogQWxsb3dlZFNldCB7XG4gICAgcmV0dXJuIG5ldyBJZHNBbGxvd2VkU2V0KG5ldyBTZXQoaWRzKSk7XG4gIH1cblxuICBzdGF0aWMgZnJvbU5hbWVzcGFjZShuYW1lc3BhY2U6IHN0cmluZyk6IEFsbG93ZWRTZXQge1xuICAgIHJldHVybiBuZXcgTmFtZXNwYWNlQWxsb3dlZFNldChuYW1lc3BhY2UpO1xuICB9XG5cbiAgc3RhdGljIGZyb21GaWx0ZXIoZmlsdGVyRm46IChpZDogc3RyaW5nLCBtZXRhZGF0YT86IFJlY29yZDxzdHJpbmcsIGFueT4pID0+IGJvb2xlYW4pOiBBbGxvd2VkU2V0IHtcbiAgICByZXR1cm4gbmV3IEZpbHRlckFsbG93ZWRTZXQoZmlsdGVyRm4pO1xuICB9XG5cbiAgc3RhdGljIGFsbG93QWxsKCk6IEFsbG93ZWRTZXQge1xuICAgIHJldHVybiBuZXcgQWxsQWxsb3dlZFNldCgpO1xuICB9XG59XG5cbmNsYXNzIElkc0FsbG93ZWRTZXQgZXh0ZW5kcyBBbGxvd2VkU2V0IHtcbiAgY29uc3RydWN0b3IocHJpdmF0ZSBpZHM6IFNldDxzdHJpbmc+KSB7XG4gICAgc3VwZXIoKTtcbiAgfVxuXG4gIGNvbnRhaW5zKGlkOiBzdHJpbmcpOiBib29sZWFuIHtcbiAgICByZXR1cm4gdGhpcy5pZHMuaGFzKGlkKTtcbiAgfVxufVxuXG5jbGFzcyBOYW1lc3BhY2VBbGxvd2VkU2V0IGV4dGVuZHMgQWxsb3dlZFNldCB7XG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgbmFtZXNwYWNlOiBzdHJpbmcpIHtcbiAgICBzdXBlcigpO1xuICB9XG5cbiAgY29udGFpbnMoaWQ6IHN0cmluZyk6IGJvb2xlYW4ge1xuICAgIHJldHVybiBpZC5zdGFydHNXaXRoKGAke3RoaXMubmFtZXNwYWNlfV9gKSB8fCBpZC5zdGFydHNXaXRoKGAke3RoaXMubmFtZXNwYWNlfTpgKTtcbiAgfVxufVxuXG5jbGFzcyBGaWx0ZXJBbGxvd2VkU2V0IGV4dGVuZHMgQWxsb3dlZFNldCB7XG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgZmlsdGVyRm46IChpZDogc3RyaW5nLCBtZXRhZGF0YT86IFJlY29yZDxzdHJpbmcsIGFueT4pID0+IGJvb2xlYW4pIHtcbiAgICBzdXBlcigpO1xuICB9XG5cbiAgY29udGFpbnMoaWQ6IHN0cmluZywgbWV0YWRhdGE/OiBSZWNvcmQ8c3RyaW5nLCBhbnk+KTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuZmlsdGVyRm4oaWQsIG1ldGFkYXRhKTtcbiAgfVxufVxuXG5jbGFzcyBBbGxBbGxvd2VkU2V0IGV4dGVuZHMgQWxsb3dlZFNldCB7XG4gIGNvbnRhaW5zKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0cnVlO1xuICB9XG59XG5cbi8qKlxuICogTmFtZXNwYWNlIHBvbGljeVxuICovXG5leHBvcnQgZW51bSBOYW1lc3BhY2VQb2xpY3kge1xuICBTVFJJQ1QgPSAnc3RyaWN0JyxcbiAgRVhQTElDSVQgPSAnZXhwbGljaXQnLFxuICBQRVJNSVNTSVZFID0gJ3Blcm1pc3NpdmUnLFxufVxuXG4vKipcbiAqIENyb3NzLW5hbWVzcGFjZSBncmFudFxuICovXG5leHBvcnQgaW50ZXJmYWNlIE5hbWVzcGFjZUdyYW50IHtcbiAgaWQ6IHN0cmluZztcbiAgZnJvbU5hbWVzcGFjZTogc3RyaW5nO1xuICB0b05hbWVzcGFjZTogc3RyaW5nO1xuICBvcGVyYXRpb25zOiBzdHJpbmdbXTtcbiAgZXhwaXJlc0F0PzogbnVtYmVyO1xuICByZWFzb24/OiBzdHJpbmc7XG59XG4iXX0=