@danielsimonjr/memory-mcp 11.0.1 → 11.1.1

package/dist/core/TransactionManager.js

@@ -9,7 +9,6 @@
  */
 import { IOManager } from '../features/IOManager.js';
 import { KnowledgeGraphError } from '../utils/errors.js';
-import { checkCancellation, createProgressReporter, createProgress, sanitizeObject } from '../utils/index.js';
 /**
  * Types of operations that can be performed in a transaction.
  */
@@ -192,11 +191,7 @@ export class TransactionManager {
      * Creates a backup before applying changes. If any operation fails,
      * automatically rolls back to the pre-transaction state.
      *
-     * Phase 9B: Supports progress tracking and cancellation via LongRunningOperationOptions.
-     *
-     * @param options - Optional progress/cancellation options (Phase 9B)
      * @returns Promise resolving to transaction result
-     * @throws {OperationCancelledError} If operation is cancelled via signal (Phase 9B)
      *
      * @example
      * ```typescript
@@ -210,53 +205,27 @@ export class TransactionManager {
      * } else {
      *   console.error(`Transaction failed: ${result.error}`);
      * }
-     *
-     * // With progress tracking (Phase 9B)
-     * const result = await txManager.commit({
-     *   onProgress: (p) => console.log(`${p.percentage}% complete`),
-     * });
      * ```
      */
-    async commit(options) {
+    async commit() {
         this.ensureInTransaction();
-        // Setup progress reporter
-        const reportProgress = createProgressReporter(options?.onProgress);
-        const totalOperations = this.operations.length;
-        reportProgress?.(createProgress(0, 100, 'commit'));
         try {
-            // Check for early cancellation (inside try block to handle gracefully)
-            checkCancellation(options?.signal, 'commit');
-            // Phase 1: Create backup for rollback (0-20% progress)
-            reportProgress?.(createProgress(5, 100, 'creating backup'));
+            // Create backup for rollback
             const backupResult = await this.ioManager.createBackup({
                 description: 'Transaction backup (auto-created)',
             });
             this.transactionBackup = backupResult.path;
-            // Check for cancellation after backup
-            checkCancellation(options?.signal, 'commit');
-            reportProgress?.(createProgress(20, 100, 'backup created'));
-            // Phase 2: Load graph (20-30% progress)
-            reportProgress?.(createProgress(25, 100, 'loading graph'));
+            // Load mutable copy of graph for transaction
             const graph = await this.storage.getGraphForMutation();
             const timestamp = new Date().toISOString();
-            reportProgress?.(createProgress(30, 100, 'graph loaded'));
-            // Phase 3: Apply all operations (30-80% progress)
+            // Apply all operations
             let operationsExecuted = 0;
             for (const operation of this.operations) {
-                // Check for cancellation between operations
-                checkCancellation(options?.signal, 'commit');
                 this.applyOperation(graph, operation, timestamp);
                 operationsExecuted++;
-                // Map operation progress (0-100%) to overall progress (30-80%)
-                const opProgress = totalOperations > 0 ? Math.round(30 + (operationsExecuted / totalOperations) * 50) : 80;
-                reportProgress?.(createProgress(opProgress, 100, 'applying operations'));
             }
-            // Check for cancellation before save
-            checkCancellation(options?.signal, 'commit');
-            // Phase 4: Save the modified graph (80-95% progress)
-            reportProgress?.(createProgress(85, 100, 'saving graph'));
+            // Save the modified graph
             await this.storage.saveGraph(graph);
-            reportProgress?.(createProgress(95, 100, 'graph saved'));
             // Clean up transaction state
             this.inTransaction = false;
             this.operations = [];
@@ -265,8 +234,6 @@ export class TransactionManager {
                 await this.ioManager.deleteBackup(this.transactionBackup);
                 this.transactionBackup = undefined;
             }
-            // Report completion
-            reportProgress?.(createProgress(100, 100, 'commit'));
             return {
                 success: true,
                 operationsExecuted,
@@ -377,8 +344,7 @@ export class TransactionManager {
                 if (!entity) {
                     throw new KnowledgeGraphError(`Entity "${name}" not found`, 'ENTITY_NOT_FOUND');
                 }
-                // Sanitize updates to prevent prototype pollution
-                Object.assign(entity, sanitizeObject(updates));
+                Object.assign(entity, updates);
                 entity.lastModified = timestamp;
                 break;
             }
@@ -424,445 +390,3 @@ export class TransactionManager {
         }
     }
 }
-// ==================== Phase 10 Sprint 1: BatchTransaction ====================
-/**
- * Phase 10 Sprint 1: Fluent API for building and executing batch transactions.
- *
- * BatchTransaction provides a builder pattern for accumulating multiple
- * graph operations and executing them atomically in a single transaction.
- * This reduces I/O overhead and ensures consistency across related changes.
- *
- * @example
- * ```typescript
- * const storage = new GraphStorage('/data/memory.jsonl');
- * const batch = new BatchTransaction(storage);
- *
- * // Build the batch with fluent API
- * const result = await batch
- *   .createEntity({ name: 'Alice', entityType: 'person', observations: ['Developer'] })
- *   .createEntity({ name: 'Bob', entityType: 'person', observations: ['Designer'] })
- *   .createRelation({ from: 'Alice', to: 'Bob', relationType: 'knows' })
- *   .updateEntity('Alice', { importance: 8 })
- *   .execute();
- *
- * if (result.success) {
- *   console.log(`Batch completed: ${result.operationsExecuted} operations in ${result.executionTimeMs}ms`);
- * }
- * ```
- */
-export class BatchTransaction {
-    operations = [];
-    storage;
-    /**
-     * Create a new BatchTransaction instance.
-     *
-     * @param storage - GraphStorage instance to execute operations against
-     */
-    constructor(storage) {
-        this.storage = storage;
-    }
-    /**
-     * Add a create entity operation to the batch.
-     *
-     * @param entity - Entity to create (without timestamps)
-     * @returns This BatchTransaction for chaining
-     *
-     * @example
-     * ```typescript
-     * batch.createEntity({
-     *   name: 'Alice',
-     *   entityType: 'person',
-     *   observations: ['Software engineer'],
-     *   importance: 8
-     * });
-     * ```
-     */
-    createEntity(entity) {
-        this.operations.push({ type: 'createEntity', data: entity });
-        return this;
-    }
-    /**
-     * Add an update entity operation to the batch.
-     *
-     * @param name - Name of entity to update
-     * @param updates - Partial entity updates
-     * @returns This BatchTransaction for chaining
-     *
-     * @example
-     * ```typescript
-     * batch.updateEntity('Alice', { importance: 9 });
-     * ```
-     */
-    updateEntity(name, updates) {
-        this.operations.push({ type: 'updateEntity', data: { name, updates } });
-        return this;
-    }
-    /**
-     * Add a delete entity operation to the batch.
-     *
-     * @param name - Name of entity to delete
-     * @returns This BatchTransaction for chaining
-     *
-     * @example
-     * ```typescript
-     * batch.deleteEntity('OldEntity');
-     * ```
-     */
-    deleteEntity(name) {
-        this.operations.push({ type: 'deleteEntity', data: { name } });
-        return this;
-    }
-    /**
-     * Add a create relation operation to the batch.
-     *
-     * @param relation - Relation to create (without timestamps)
-     * @returns This BatchTransaction for chaining
-     *
-     * @example
-     * ```typescript
-     * batch.createRelation({
-     *   from: 'Alice',
-     *   to: 'Bob',
-     *   relationType: 'mentors'
-     * });
-     * ```
-     */
-    createRelation(relation) {
-        this.operations.push({ type: 'createRelation', data: relation });
-        return this;
-    }
-    /**
-     * Add a delete relation operation to the batch.
-     *
-     * @param from - Source entity name
-     * @param to - Target entity name
-     * @param relationType - Type of relation
-     * @returns This BatchTransaction for chaining
-     *
-     * @example
-     * ```typescript
-     * batch.deleteRelation('Alice', 'Bob', 'mentors');
-     * ```
-     */
-    deleteRelation(from, to, relationType) {
-        this.operations.push({ type: 'deleteRelation', data: { from, to, relationType } });
-        return this;
-    }
-    /**
-     * Add observations to an existing entity.
-     *
-     * @param name - Name of entity to add observations to
-     * @param observations - Observations to add
-     * @returns This BatchTransaction for chaining
-     *
-     * @example
-     * ```typescript
-     * batch.addObservations('Alice', ['Knows TypeScript', 'Leads team']);
-     * ```
-     */
-    addObservations(name, observations) {
-        this.operations.push({ type: 'addObservations', data: { name, observations } });
-        return this;
-    }
-    /**
-     * Delete observations from an existing entity.
-     *
-     * @param name - Name of entity to delete observations from
-     * @param observations - Observations to delete
-     * @returns This BatchTransaction for chaining
-     *
-     * @example
-     * ```typescript
-     * batch.deleteObservations('Alice', ['Old fact']);
-     * ```
-     */
-    deleteObservations(name, observations) {
-        this.operations.push({ type: 'deleteObservations', data: { name, observations } });
-        return this;
-    }
-    /**
-     * Add multiple operations from an array.
-     *
-     * @param operations - Array of batch operations
-     * @returns This BatchTransaction for chaining
-     *
-     * @example
-     * ```typescript
-     * batch.addOperations([
-     *   { type: 'createEntity', data: { name: 'A', entityType: 'x', observations: [] } },
-     *   { type: 'createEntity', data: { name: 'B', entityType: 'x', observations: [] } }
-     * ]);
-     * ```
-     */
-    addOperations(operations) {
-        this.operations.push(...operations);
-        return this;
-    }
-    /**
-     * Get the number of operations in this batch.
-     *
-     * @returns Number of operations queued
-     */
-    size() {
-        return this.operations.length;
-    }
-    /**
-     * Clear all operations from the batch.
-     *
-     * @returns This BatchTransaction for chaining
-     */
-    clear() {
-        this.operations = [];
-        return this;
-    }
-    /**
-     * Get a copy of the operations in this batch.
-     *
-     * @returns Array of batch operations
-     */
-    getOperations() {
-        return [...this.operations];
-    }
-    /**
-     * Execute all operations in the batch atomically.
-     *
-     * All operations are applied within a single transaction. If any
-     * operation fails, all changes are rolled back (when stopOnError is true).
-     *
-     * @param options - Batch execution options
-     * @returns Promise resolving to batch result
-     *
-     * @example
-     * ```typescript
-     * const result = await batch.execute();
-     * if (result.success) {
-     *   console.log(`Created ${result.entitiesCreated} entities`);
-     * } else {
-     *   console.error(`Failed at operation ${result.failedOperationIndex}: ${result.error}`);
-     * }
-     * ```
-     */
-    async execute(options = {}) {
-        const startTime = Date.now();
-        const { stopOnError = true, validateBeforeExecute = true } = options;
-        const result = {
-            success: true,
-            operationsExecuted: 0,
-            entitiesCreated: 0,
-            entitiesUpdated: 0,
-            entitiesDeleted: 0,
-            relationsCreated: 0,
-            relationsDeleted: 0,
-            executionTimeMs: 0,
-        };
-        if (this.operations.length === 0) {
-            result.executionTimeMs = Date.now() - startTime;
-            return result;
-        }
-        // Load graph for mutation
-        const graph = await this.storage.getGraphForMutation();
-        const timestamp = new Date().toISOString();
-        // Optional: Validate all operations before executing
-        if (validateBeforeExecute) {
-            const validationError = this.validateOperations(graph);
-            if (validationError) {
-                return {
-                    ...result,
-                    success: false,
-                    error: validationError.message,
-                    failedOperationIndex: validationError.index,
-                    executionTimeMs: Date.now() - startTime,
-                };
-            }
-        }
-        // Execute operations
-        for (let i = 0; i < this.operations.length; i++) {
-            const operation = this.operations[i];
-            try {
-                this.applyBatchOperation(graph, operation, timestamp, result);
-                result.operationsExecuted++;
-            }
-            catch (error) {
-                result.success = false;
-                result.error = error instanceof Error ? error.message : String(error);
-                result.failedOperationIndex = i;
-                if (stopOnError) {
-                    result.executionTimeMs = Date.now() - startTime;
-                    return result;
-                }
-            }
-        }
-        // Save the modified graph if successful (or if stopOnError is false)
-        if (result.success || !stopOnError) {
-            try {
-                await this.storage.saveGraph(graph);
-            }
-            catch (error) {
-                result.success = false;
-                result.error = `Failed to save graph: ${error instanceof Error ? error.message : String(error)}`;
-            }
-        }
-        result.executionTimeMs = Date.now() - startTime;
-        return result;
-    }
-    /**
-     * Validate all operations before executing.
-     * @private
-     */
-    validateOperations(graph) {
-        const entityNames = new Set(graph.entities.map(e => e.name));
-        const pendingCreates = new Set();
-        const pendingDeletes = new Set();
-        for (let i = 0; i < this.operations.length; i++) {
-            const op = this.operations[i];
-            switch (op.type) {
-                case 'createEntity': {
-                    const name = op.data.name;
-                    if (entityNames.has(name) && !pendingDeletes.has(name)) {
-                        return { message: `Entity "${name}" already exists`, index: i };
-                    }
-                    if (pendingCreates.has(name)) {
-                        return { message: `Duplicate create for entity "${name}" in batch`, index: i };
-                    }
-                    pendingCreates.add(name);
-                    break;
-                }
-                case 'updateEntity':
-                case 'addObservations':
-                case 'deleteObservations': {
-                    const name = op.data.name;
-                    const exists = (entityNames.has(name) || pendingCreates.has(name)) && !pendingDeletes.has(name);
-                    if (!exists) {
-                        return { message: `Entity "${name}" not found`, index: i };
-                    }
-                    break;
-                }
-                case 'deleteEntity': {
-                    const name = op.data.name;
-                    const exists = (entityNames.has(name) || pendingCreates.has(name)) && !pendingDeletes.has(name);
-                    if (!exists) {
-                        return { message: `Entity "${name}" not found for deletion`, index: i };
-                    }
-                    pendingDeletes.add(name);
-                    break;
-                }
-                case 'createRelation': {
-                    const { from, to } = op.data;
-                    const fromExists = (entityNames.has(from) || pendingCreates.has(from)) && !pendingDeletes.has(from);
-                    const toExists = (entityNames.has(to) || pendingCreates.has(to)) && !pendingDeletes.has(to);
-                    if (!fromExists) {
-                        return { message: `Source entity "${from}" not found for relation`, index: i };
-                    }
-                    if (!toExists) {
-                        return { message: `Target entity "${to}" not found for relation`, index: i };
-                    }
-                    break;
-                }
-                case 'deleteRelation': {
-                    // Relations are validated at execution time
-                    break;
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Apply a single batch operation to the graph.
-     * @private
-     */
-    applyBatchOperation(graph, operation, timestamp, result) {
-        switch (operation.type) {
-            case 'createEntity': {
-                const entity = {
-                    ...operation.data,
-                    createdAt: timestamp,
-                    lastModified: timestamp,
-                };
-                if (graph.entities.some(e => e.name === entity.name)) {
-                    throw new KnowledgeGraphError(`Entity "${entity.name}" already exists`, 'DUPLICATE_ENTITY');
-                }
-                graph.entities.push(entity);
-                result.entitiesCreated++;
-                break;
-            }
-            case 'updateEntity': {
-                const { name, updates } = operation.data;
-                const entity = graph.entities.find(e => e.name === name);
-                if (!entity) {
-                    throw new KnowledgeGraphError(`Entity "${name}" not found`, 'ENTITY_NOT_FOUND');
-                }
-                // Sanitize updates to prevent prototype pollution
-                Object.assign(entity, sanitizeObject(updates));
-                entity.lastModified = timestamp;
-                result.entitiesUpdated++;
-                break;
-            }
-            case 'deleteEntity': {
-                const { name } = operation.data;
-                const index = graph.entities.findIndex(e => e.name === name);
-                if (index === -1) {
-                    throw new KnowledgeGraphError(`Entity "${name}" not found`, 'ENTITY_NOT_FOUND');
-                }
-                graph.entities.splice(index, 1);
-                // Delete related relations
-                graph.relations = graph.relations.filter(r => r.from !== name && r.to !== name);
-                result.entitiesDeleted++;
-                break;
-            }
-            case 'createRelation': {
-                const relation = {
-                    ...operation.data,
-                    createdAt: timestamp,
-                    lastModified: timestamp,
-                };
-                const exists = graph.relations.some(r => r.from === relation.from && r.to === relation.to && r.relationType === relation.relationType);
-                if (exists) {
-                    throw new KnowledgeGraphError(`Relation "${relation.from}" -> "${relation.to}" (${relation.relationType}) already exists`, 'DUPLICATE_RELATION');
-                }
-                graph.relations.push(relation);
-                result.relationsCreated++;
-                break;
-            }
-            case 'deleteRelation': {
-                const { from, to, relationType } = operation.data;
-                const index = graph.relations.findIndex(r => r.from === from && r.to === to && r.relationType === relationType);
-                if (index === -1) {
-                    throw new KnowledgeGraphError(`Relation "${from}" -> "${to}" (${relationType}) not found`, 'RELATION_NOT_FOUND');
-                }
-                graph.relations.splice(index, 1);
-                result.relationsDeleted++;
-                break;
-            }
-            case 'addObservations': {
-                const { name, observations } = operation.data;
-                const entity = graph.entities.find(e => e.name === name);
-                if (!entity) {
-                    throw new KnowledgeGraphError(`Entity "${name}" not found`, 'ENTITY_NOT_FOUND');
-                }
-                // Add only new observations
-                const existingSet = new Set(entity.observations);
-                const newObs = observations.filter((o) => !existingSet.has(o));
-                entity.observations.push(...newObs);
-                entity.lastModified = timestamp;
-                result.entitiesUpdated++;
-                break;
-            }
-            case 'deleteObservations': {
-                const { name, observations } = operation.data;
-                const entity = graph.entities.find(e => e.name === name);
-                if (!entity) {
-                    throw new KnowledgeGraphError(`Entity "${name}" not found`, 'ENTITY_NOT_FOUND');
-                }
-                const toDelete = new Set(observations);
-                entity.observations = entity.observations.filter((o) => !toDelete.has(o));
-                entity.lastModified = timestamp;
-                result.entitiesUpdated++;
-                break;
-            }
-            default: {
-                const _exhaustiveCheck = operation;
-                throw new KnowledgeGraphError(`Unknown batch operation type: ${_exhaustiveCheck.type}`, 'UNKNOWN_OPERATION');
-            }
-        }
-    }
-}

package/dist/core/index.d.ts

@@ -11,7 +11,6 @@ export { HierarchyManager } from './HierarchyManager.js';
 export { ManagerContext } from './ManagerContext.js';
 export { GraphTraversal } from './GraphTraversal.js';
 export { ManagerContext as KnowledgeGraphManager } from './ManagerContext.js';
-export { TransactionManager, OperationType, BatchTransaction, type TransactionOperation, type TransactionResult, } from './TransactionManager.js';
+export { TransactionManager, OperationType, type TransactionOperation, type TransactionResult, } from './TransactionManager.js';
 export { createStorage, createStorageFromPath } from './StorageFactory.js';
-export { GraphEventEmitter } from './GraphEventEmitter.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,cAAc,IAAI,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC9E,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,gBAAgB,EAChB,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,GACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAE3E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,cAAc,IAAI,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC9E,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,GACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/core/index.js

@@ -13,7 +13,5 @@ export { ManagerContext } from './ManagerContext.js';
 export { GraphTraversal } from './GraphTraversal.js';
 // Backward compatibility alias
 export { ManagerContext as KnowledgeGraphManager } from './ManagerContext.js';
-export { TransactionManager, OperationType, BatchTransaction, } from './TransactionManager.js';
+export { TransactionManager, OperationType, } from './TransactionManager.js';
 export { createStorage, createStorageFromPath } from './StorageFactory.js';
-// Phase 10 Sprint 2: Graph change events
-export { GraphEventEmitter } from './GraphEventEmitter.js';

package/dist/features/ArchiveManager.d.ts

@@ -8,7 +8,6 @@
  *
  * @module features/ArchiveManager
  */
-import type { LongRunningOperationOptions } from '../types/index.js';
 import type { GraphStorage } from '../core/GraphStorage.js';
 /**
  * Criteria for archiving entities.
@@ -23,9 +22,8 @@ export interface ArchiveCriteria {
 }
 /**
  * Options for archive operations.
- * Phase 9B: Extended with LongRunningOperationOptions.
  */
-export interface ArchiveOptions extends LongRunningOperationOptions {
+export interface ArchiveOptions {
     /** Dry run mode - preview without making changes */
     dryRun?: boolean;
     /** Whether to save archived entities to a compressed file (default: true) */
@@ -71,12 +69,9 @@ export declare class ArchiveManager {
      * being removed from the active graph. Use `saveToFile: false` to
      * skip creating the archive file.
      *
-     * Phase 9B: Supports progress tracking and cancellation via options.
-     *
      * @param criteria - Archiving criteria
-     * @param options - Archive options (dryRun, saveToFile, onProgress, signal)
+     * @param options - Archive options (dryRun, saveToFile)
      * @returns Archive result with count, entity names, and compression stats
-     * @throws {OperationCancelledError} If operation is cancelled via signal (Phase 9B)
      *
      * @example
      * ```typescript
@@ -90,13 +85,6 @@ export declare class ArchiveManager {
      *
      * // Preview without making changes
      * const preview = await manager.archiveEntities(criteria, { dryRun: true });
-     *
-     * // With progress tracking and cancellation (Phase 9B)
-     * const controller = new AbortController();
-     * const result = await manager.archiveEntities(criteria, {
-     *   signal: controller.signal,
-     *   onProgress: (p) => console.log(`${p.percentage}% complete`),
-     * });
      * ```
      */
     archiveEntities(criteria: ArchiveCriteria, options?: ArchiveOptions | boolean): Promise<ArchiveResult>;

package/dist/features/ArchiveManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ArchiveManager.d.ts","sourceRoot":"","sources":["../../src/features/ArchiveManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAU,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAS5D;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAe,SAAQ,2BAA2B;IACjE,oDAAoD;IACpD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,6EAA6E;IAC7E,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,iCAAiC;IACjC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,4CAA4C;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+BAA+B;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,qBAAa,cAAc;IAGb,OAAO,CAAC,OAAO;IAF3B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAEhB,OAAO,EAAE,YAAY;IAMzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACG,eAAe,CACnB,QAAQ,EAAE,eAAe,EACzB,OAAO,GAAE,cAAc,GAAG,OAAY,GACrC,OAAO,CAAC,aAAa,CAAC;IAuIzB;;;;;;;;OAQG;YACW,aAAa;IAmD3B;;;;OAIG;IACG,YAAY,IAAI,OAAO,CAAC,KAAK,CAAC;QAClC,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,OAAO,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC,CAAC;IA6DH;;OAEG;IACH,aAAa,IAAI,MAAM;CAGxB"}
+{"version":3,"file":"ArchiveManager.d.ts","sourceRoot":"","sources":["../../src/features/ArchiveManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAG5D;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,oDAAoD;IACpD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,6EAA6E;IAC7E,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,iCAAiC;IACjC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,4CAA4C;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+BAA+B;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,qBAAa,cAAc;IAGb,OAAO,CAAC,OAAO;IAF3B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAEhB,OAAO,EAAE,YAAY;IAMzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,eAAe,CACnB,QAAQ,EAAE,eAAe,EACzB,OAAO,GAAE,cAAc,GAAG,OAAY,GACrC,OAAO,CAAC,aAAa,CAAC;IA+FzB;;;;;;;;OAQG;YACW,aAAa;IAmD3B;;;;OAIG;IACG,YAAY,IAAI,OAAO,CAAC,KAAK,CAAC;QAClC,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,OAAO,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC,CAAC;IA6DH;;OAEG;IACH,aAAa,IAAI,MAAM;CAGxB"}