agentic-qe 2.7.4 → 2.8.0

package/dist/edge/p2p/crdt/PatternCRDT.js

@@ -0,0 +1,838 @@
+"use strict";
+/**
+ * Pattern CRDT - Specialized CRDT for SharedPattern Objects
+ *
+ * A composite CRDT that manages SharedPattern objects with different
+ * CRDT strategies for different fields:
+ * - LWW for scalar fields (content, type, category, domain)
+ * - ORSet for collection fields (tags)
+ * - GCounter for usage metrics
+ *
+ * @module edge/p2p/crdt/PatternCRDT
+ * @version 1.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternCRDT = void 0;
+const types_1 = require("./types");
+const VectorClock_1 = require("./VectorClock");
+const GCounter_1 = require("./GCounter");
+const LWWRegister_1 = require("./LWWRegister");
+const ORSet_1 = require("./ORSet");
+// ============================================
+// Default Values
+// ============================================
+const DEFAULT_QUALITY = {
+    level: 'unverified',
+    successRate: 0,
+    uniqueUsers: 0,
+    avgConfidence: 0,
+    feedbackScore: 0,
+};
+const DEFAULT_SHARING_CONFIG = {
+    policy: 'public',
+    privacyLevel: 'anonymized',
+    redistributable: true,
+};
+// ============================================
+// PatternCRDT Class
+// ============================================
+/**
+ * Composite CRDT for SharedPattern objects.
+ *
+ * Combines multiple CRDT types to provide automatic conflict resolution
+ * for pattern data:
+ * - Content, type, category, domain use LWW semantics
+ * - Tags use OR-Set semantics (add wins)
+ * - Usage count uses G-Counter
+ * - Metadata fields use LWW
+ *
+ * @example
+ * ```typescript
+ * const pattern = new PatternCRDT('replica-1', {
+ *   id: 'pattern-1',
+ *   content: 'test code...',
+ *   type: 'unit-test',
+ *   category: 'test',
+ *   domain: 'api',
+ *   tags: ['typescript', 'jest'],
+ * });
+ *
+ * // Update fields
+ * pattern.setContent('updated code...');
+ * pattern.addTag('integration');
+ * pattern.incrementUsage();
+ *
+ * // Merge with remote
+ * pattern.merge(remoteState);
+ *
+ * // Get current data
+ * const data = pattern.getData();
+ * ```
+ */
+class PatternCRDT {
+    /**
+     * Create a new PatternCRDT
+     *
+     * @param replicaId - Local replica identifier
+     * @param input - Pattern input data
+     * @param options - Optional configuration
+     */
+    constructor(replicaId, input, options) {
+        this.id = input.id;
+        this.replicaId = replicaId;
+        this.maxHistorySize = options?.maxHistorySize ?? 100;
+        // Initialize LWW registers
+        this.content = new LWWRegister_1.LWWRegister(replicaId, `${input.id}-content`, input.content);
+        this.type = new LWWRegister_1.LWWRegister(replicaId, `${input.id}-type`, input.type);
+        this.category = new LWWRegister_1.LWWRegister(replicaId, `${input.id}-category`, input.category);
+        this.domain = new LWWRegister_1.LWWRegister(replicaId, `${input.id}-domain`, input.domain);
+        this.quality = new LWWRegister_1.LWWRegister(replicaId, `${input.id}-quality`, input.quality ?? DEFAULT_QUALITY);
+        this.sharingConfig = new LWWRegister_1.LWWRegister(replicaId, `${input.id}-sharing`, input.sharingConfig ?? DEFAULT_SHARING_CONFIG);
+        // Initialize ORSet for tags
+        this.tags = new ORSet_1.ORSet(replicaId, `${input.id}-tags`);
+        if (input.tags) {
+            for (const tag of input.tags) {
+                this.tags.add(tag);
+            }
+        }
+        // Initialize GCounter for usage
+        this.usageCount = new GCounter_1.GCounter(replicaId, `${input.id}-usage`, 0);
+        // Initialize metadata map
+        this.metadata = new Map();
+        if (input.metadata) {
+            for (const [key, value] of Object.entries(input.metadata)) {
+                this.metadata.set(key, new LWWRegister_1.LWWRegister(replicaId, `${input.id}-meta-${key}`, value));
+            }
+        }
+        // Initialize vector clock
+        this.vectorClock = new VectorClock_1.VectorClock(replicaId);
+        this.vectorClock.increment();
+        this.sequenceNumber = 0;
+        this.lastDeltaClock = this.vectorClock.clone();
+        this.history = [];
+        const now = Date.now();
+        this.crdtMetadata = {
+            createdAt: now,
+            updatedAt: now,
+            mergeCount: 0,
+            lastModifiedBy: replicaId,
+        };
+    }
+    // ============================================
+    // Getters
+    // ============================================
+    /**
+     * Get the current pattern data
+     *
+     * @returns Complete pattern data
+     */
+    value() {
+        return this.getData();
+    }
+    /**
+     * Get the current pattern data
+     *
+     * @returns Complete pattern data
+     */
+    getData() {
+        const metadataObj = {};
+        for (const [key, register] of this.metadata) {
+            metadataObj[key] = register.value();
+        }
+        return {
+            id: this.id,
+            content: this.content.value() ?? '',
+            type: this.type.value() ?? '',
+            category: this.category.value() ?? '',
+            domain: this.domain.value() ?? '',
+            tags: this.tags.values(),
+            metadata: metadataObj,
+            quality: this.quality.value() ?? DEFAULT_QUALITY,
+            usageCount: this.usageCount.value(),
+            sharingConfig: this.sharingConfig.value() ?? DEFAULT_SHARING_CONFIG,
+            lastModified: this.vectorClock.getLastModified(),
+        };
+    }
+    /**
+     * Get the pattern ID
+     *
+     * @returns Pattern ID
+     */
+    getId() {
+        return this.id;
+    }
+    /**
+     * Get the content
+     *
+     * @returns Pattern content
+     */
+    getContent() {
+        return this.content.value() ?? '';
+    }
+    /**
+     * Get the type
+     *
+     * @returns Pattern type
+     */
+    getType() {
+        return this.type.value() ?? '';
+    }
+    /**
+     * Get the category
+     *
+     * @returns Pattern category
+     */
+    getCategory() {
+        return this.category.value() ?? '';
+    }
+    /**
+     * Get the domain
+     *
+     * @returns Pattern domain
+     */
+    getDomain() {
+        return this.domain.value() ?? '';
+    }
+    /**
+     * Get all tags
+     *
+     * @returns Array of tags
+     */
+    getTags() {
+        return this.tags.values();
+    }
+    /**
+     * Get the usage count
+     *
+     * @returns Usage count
+     */
+    getUsageCount() {
+        return this.usageCount.value();
+    }
+    /**
+     * Get a metadata value
+     *
+     * @param key - Metadata key
+     * @returns Metadata value or undefined
+     */
+    getMetadata(key) {
+        return this.metadata.get(key)?.value();
+    }
+    /**
+     * Get the modification history
+     *
+     * @returns History entries
+     */
+    getHistory() {
+        return [...this.history];
+    }
+    // ============================================
+    // Setters
+    // ============================================
+    /**
+     * Set the content
+     *
+     * @param content - New content
+     */
+    setContent(content) {
+        this.recordHistory('content', this.content.value(), content);
+        this.content.set(content);
+        this.updateState();
+    }
+    /**
+     * Set the type
+     *
+     * @param type - New type
+     */
+    setType(type) {
+        this.recordHistory('type', this.type.value(), type);
+        this.type.set(type);
+        this.updateState();
+    }
+    /**
+     * Set the category
+     *
+     * @param category - New category
+     */
+    setCategory(category) {
+        this.recordHistory('category', this.category.value(), category);
+        this.category.set(category);
+        this.updateState();
+    }
+    /**
+     * Set the domain
+     *
+     * @param domain - New domain
+     */
+    setDomain(domain) {
+        this.recordHistory('domain', this.domain.value(), domain);
+        this.domain.set(domain);
+        this.updateState();
+    }
+    /**
+     * Add a tag
+     *
+     * @param tag - Tag to add
+     * @returns Tag identifier
+     */
+    addTag(tag) {
+        this.recordHistory('tags', this.tags.values(), [...this.tags.values(), tag]);
+        const result = this.tags.add(tag);
+        this.updateState();
+        return result;
+    }
+    /**
+     * Remove a tag
+     *
+     * @param tag - Tag to remove
+     * @returns Number of tags removed
+     */
+    removeTag(tag) {
+        const currentTags = this.tags.values();
+        const count = this.tags.remove(tag);
+        if (count > 0) {
+            this.recordHistory('tags', currentTags, this.tags.values());
+            this.updateState();
+        }
+        return count;
+    }
+    /**
+     * Set a metadata value
+     *
+     * @param key - Metadata key
+     * @param value - Metadata value
+     */
+    setMetadata(key, value) {
+        const existing = this.metadata.get(key);
+        if (existing) {
+            this.recordHistory(`metadata.${key}`, existing.value(), value);
+            existing.set(value);
+        }
+        else {
+            this.recordHistory(`metadata.${key}`, undefined, value);
+            this.metadata.set(key, new LWWRegister_1.LWWRegister(this.replicaId, `${this.id}-meta-${key}`, value));
+        }
+        this.updateState();
+    }
+    /**
+     * Remove a metadata entry
+     *
+     * @param key - Key to remove
+     * @returns True if removed
+     */
+    removeMetadata(key) {
+        const existing = this.metadata.get(key);
+        if (existing) {
+            this.recordHistory(`metadata.${key}`, existing.value(), undefined);
+            this.metadata.delete(key);
+            this.updateState();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Increment the usage count
+     *
+     * @param amount - Amount to increment (default 1)
+     * @returns New usage count
+     */
+    incrementUsage(amount = 1) {
+        const result = this.usageCount.increment(amount);
+        this.updateState();
+        return result;
+    }
+    /**
+     * Set quality metrics
+     *
+     * @param quality - New quality metrics
+     */
+    setQuality(quality) {
+        this.recordHistory('quality', this.quality.value(), quality);
+        this.quality.set(quality);
+        this.updateState();
+    }
+    /**
+     * Set sharing configuration
+     *
+     * @param config - New sharing config
+     */
+    setSharingConfig(config) {
+        this.recordHistory('sharingConfig', this.sharingConfig.value(), config);
+        this.sharingConfig.set(config);
+        this.updateState();
+    }
+    // ============================================
+    // State Management
+    // ============================================
+    /**
+     * Update internal state after modification
+     */
+    updateState() {
+        this.vectorClock.increment();
+        this.sequenceNumber++;
+        this.crdtMetadata.updatedAt = Date.now();
+        this.crdtMetadata.lastModifiedBy = this.replicaId;
+    }
+    /**
+     * Record a modification in history
+     */
+    recordHistory(field, prev, next) {
+        this.history.push({
+            field,
+            previousValue: prev,
+            newValue: next,
+            replica: this.replicaId,
+            timestamp: Date.now(),
+        });
+        // Trim history if too large
+        if (this.history.length > this.maxHistorySize) {
+            this.history = this.history.slice(-this.maxHistorySize);
+        }
+    }
+    /**
+     * Get the serializable state
+     *
+     * @returns CRDT state
+     */
+    state() {
+        const metadataObj = {};
+        for (const [key, register] of this.metadata) {
+            metadataObj[key] = register.state().value;
+        }
+        return {
+            type: types_1.CRDTType.PatternCRDT,
+            id: this.id,
+            vectorClock: this.vectorClock.serialize(),
+            origin: this.replicaId,
+            value: {
+                id: this.id,
+                content: this.content.state().value,
+                type: this.type.state().value,
+                category: this.category.state().value,
+                domain: this.domain.state().value,
+                tags: this.tags.state().value,
+                metadata: metadataObj,
+                quality: this.quality.state().value,
+                usageCount: this.usageCount.state().value,
+                sharingConfig: this.sharingConfig.state().value,
+            },
+            metadata: { ...this.crdtMetadata },
+            stateVersion: 1,
+        };
+    }
+    /**
+     * Restore a PatternCRDT from serialized state
+     *
+     * @param state - Serialized state
+     * @param replicaId - Local replica ID
+     * @returns Restored PatternCRDT
+     */
+    static fromState(state, replicaId) {
+        if (state.type !== types_1.CRDTType.PatternCRDT) {
+            throw new types_1.CRDTError(`Invalid CRDT type: expected ${types_1.CRDTType.PatternCRDT}, got ${state.type}`, types_1.CRDTErrorCode.InvalidType, state.id);
+        }
+        const v = state.value;
+        const pattern = new PatternCRDT(replicaId, {
+            id: v.id,
+            content: v.content.value,
+            type: v.type.value,
+            category: v.category.value,
+            domain: v.domain.value,
+        });
+        // Restore LWW registers with correct timestamps
+        pattern.content = LWWRegister_1.LWWRegister.fromState({
+            type: types_1.CRDTType.LWWRegister,
+            id: `${v.id}-content`,
+            vectorClock: state.vectorClock,
+            origin: state.origin,
+            value: v.content,
+            metadata: state.metadata,
+            stateVersion: 1,
+        }, replicaId);
+        pattern.type = LWWRegister_1.LWWRegister.fromState({
+            type: types_1.CRDTType.LWWRegister,
+            id: `${v.id}-type`,
+            vectorClock: state.vectorClock,
+            origin: state.origin,
+            value: v.type,
+            metadata: state.metadata,
+            stateVersion: 1,
+        }, replicaId);
+        pattern.category = LWWRegister_1.LWWRegister.fromState({
+            type: types_1.CRDTType.LWWRegister,
+            id: `${v.id}-category`,
+            vectorClock: state.vectorClock,
+            origin: state.origin,
+            value: v.category,
+            metadata: state.metadata,
+            stateVersion: 1,
+        }, replicaId);
+        pattern.domain = LWWRegister_1.LWWRegister.fromState({
+            type: types_1.CRDTType.LWWRegister,
+            id: `${v.id}-domain`,
+            vectorClock: state.vectorClock,
+            origin: state.origin,
+            value: v.domain,
+            metadata: state.metadata,
+            stateVersion: 1,
+        }, replicaId);
+        pattern.quality = LWWRegister_1.LWWRegister.fromState({
+            type: types_1.CRDTType.LWWRegister,
+            id: `${v.id}-quality`,
+            vectorClock: state.vectorClock,
+            origin: state.origin,
+            value: v.quality,
+            metadata: state.metadata,
+            stateVersion: 1,
+        }, replicaId);
+        pattern.sharingConfig = LWWRegister_1.LWWRegister.fromState({
+            type: types_1.CRDTType.LWWRegister,
+            id: `${v.id}-sharing`,
+            vectorClock: state.vectorClock,
+            origin: state.origin,
+            value: v.sharingConfig,
+            metadata: state.metadata,
+            stateVersion: 1,
+        }, replicaId);
+        // Restore ORSet for tags
+        pattern.tags = ORSet_1.ORSet.fromState({
+            type: types_1.CRDTType.ORSet,
+            id: `${v.id}-tags`,
+            vectorClock: state.vectorClock,
+            origin: state.origin,
+            value: v.tags,
+            metadata: state.metadata,
+            stateVersion: 1,
+        }, replicaId);
+        // Restore GCounter for usage
+        pattern.usageCount = GCounter_1.GCounter.fromState({
+            type: types_1.CRDTType.GCounter,
+            id: `${v.id}-usage`,
+            vectorClock: state.vectorClock,
+            origin: state.origin,
+            value: v.usageCount,
+            metadata: state.metadata,
+            stateVersion: 1,
+        }, replicaId);
+        // Restore metadata
+        pattern.metadata.clear();
+        for (const [key, lwwState] of Object.entries(v.metadata)) {
+            pattern.metadata.set(key, LWWRegister_1.LWWRegister.fromState({
+                type: types_1.CRDTType.LWWRegister,
+                id: `${v.id}-meta-${key}`,
+                vectorClock: state.vectorClock,
+                origin: state.origin,
+                value: lwwState,
+                metadata: state.metadata,
+                stateVersion: 1,
+            }, replicaId));
+        }
+        // Restore vector clock
+        pattern.vectorClock = VectorClock_1.VectorClock.fromSerialized(state.vectorClock, replicaId);
+        // Restore metadata
+        pattern.crdtMetadata = { ...state.metadata };
+        return pattern;
+    }
+    // ============================================
+    // Merge Operations
+    // ============================================
+    /**
+     * Merge with another PatternCRDT state
+     *
+     * Each field is merged according to its CRDT type:
+     * - LWW fields: last writer wins
+     * - ORSet fields: add wins for concurrent add/remove
+     * - GCounter fields: max per replica
+     *
+     * @param other - Other pattern state to merge
+     * @returns Merge result
+     */
+    merge(other) {
+        const startTime = Date.now();
+        const allConflicts = [];
+        let entriesMerged = 0;
+        let localChanged = false;
+        if (other.type !== types_1.CRDTType.PatternCRDT) {
+            throw new types_1.CRDTError(`Cannot merge different CRDT types`, types_1.CRDTErrorCode.InvalidType, this.id);
+        }
+        if (other.id !== this.id) {
+            throw new types_1.CRDTError(`Cannot merge different patterns`, types_1.CRDTErrorCode.InvalidState, this.id);
+        }
+        const v = other.value;
+        // Merge LWW fields
+        const contentResult = this.content.merge({
+            type: types_1.CRDTType.LWWRegister,
+            id: `${this.id}-content`,
+            vectorClock: other.vectorClock,
+            origin: other.origin,
+            value: v.content,
+            metadata: other.metadata,
+            stateVersion: 1,
+        });
+        if (contentResult.localChanged)
+            localChanged = true;
+        allConflicts.push(...contentResult.conflicts);
+        entriesMerged++;
+        const typeResult = this.type.merge({
+            type: types_1.CRDTType.LWWRegister,
+            id: `${this.id}-type`,
+            vectorClock: other.vectorClock,
+            origin: other.origin,
+            value: v.type,
+            metadata: other.metadata,
+            stateVersion: 1,
+        });
+        if (typeResult.localChanged)
+            localChanged = true;
+        allConflicts.push(...typeResult.conflicts);
+        entriesMerged++;
+        const categoryResult = this.category.merge({
+            type: types_1.CRDTType.LWWRegister,
+            id: `${this.id}-category`,
+            vectorClock: other.vectorClock,
+            origin: other.origin,
+            value: v.category,
+            metadata: other.metadata,
+            stateVersion: 1,
+        });
+        if (categoryResult.localChanged)
+            localChanged = true;
+        allConflicts.push(...categoryResult.conflicts);
+        entriesMerged++;
+        const domainResult = this.domain.merge({
+            type: types_1.CRDTType.LWWRegister,
+            id: `${this.id}-domain`,
+            vectorClock: other.vectorClock,
+            origin: other.origin,
+            value: v.domain,
+            metadata: other.metadata,
+            stateVersion: 1,
+        });
+        if (domainResult.localChanged)
+            localChanged = true;
+        allConflicts.push(...domainResult.conflicts);
+        entriesMerged++;
+        const qualityResult = this.quality.merge({
+            type: types_1.CRDTType.LWWRegister,
+            id: `${this.id}-quality`,
+            vectorClock: other.vectorClock,
+            origin: other.origin,
+            value: v.quality,
+            metadata: other.metadata,
+            stateVersion: 1,
+        });
+        if (qualityResult.localChanged)
+            localChanged = true;
+        allConflicts.push(...qualityResult.conflicts);
+        entriesMerged++;
+        const sharingResult = this.sharingConfig.merge({
+            type: types_1.CRDTType.LWWRegister,
+            id: `${this.id}-sharing`,
+            vectorClock: other.vectorClock,
+            origin: other.origin,
+            value: v.sharingConfig,
+            metadata: other.metadata,
+            stateVersion: 1,
+        });
+        if (sharingResult.localChanged)
+            localChanged = true;
+        allConflicts.push(...sharingResult.conflicts);
+        entriesMerged++;
+        // Merge ORSet tags
+        const tagsResult = this.tags.merge({
+            type: types_1.CRDTType.ORSet,
+            id: `${this.id}-tags`,
+            vectorClock: other.vectorClock,
+            origin: other.origin,
+            value: v.tags,
+            metadata: other.metadata,
+            stateVersion: 1,
+        });
+        if (tagsResult.localChanged)
+            localChanged = true;
+        allConflicts.push(...tagsResult.conflicts);
+        entriesMerged++;
+        // Merge GCounter usage
+        const usageResult = this.usageCount.merge({
+            type: types_1.CRDTType.GCounter,
+            id: `${this.id}-usage`,
+            vectorClock: other.vectorClock,
+            origin: other.origin,
+            value: v.usageCount,
+            metadata: other.metadata,
+            stateVersion: 1,
+        });
+        if (usageResult.localChanged)
+            localChanged = true;
+        entriesMerged++;
+        // Merge metadata entries
+        for (const [key, lwwState] of Object.entries(v.metadata)) {
+            const existing = this.metadata.get(key);
+            if (existing) {
+                const metaResult = existing.merge({
+                    type: types_1.CRDTType.LWWRegister,
+                    id: `${this.id}-meta-${key}`,
+                    vectorClock: other.vectorClock,
+                    origin: other.origin,
+                    value: lwwState,
+                    metadata: other.metadata,
+                    stateVersion: 1,
+                });
+                if (metaResult.localChanged)
+                    localChanged = true;
+                allConflicts.push(...metaResult.conflicts);
+            }
+            else {
+                this.metadata.set(key, LWWRegister_1.LWWRegister.fromState({
+                    type: types_1.CRDTType.LWWRegister,
+                    id: `${this.id}-meta-${key}`,
+                    vectorClock: other.vectorClock,
+                    origin: other.origin,
+                    value: lwwState,
+                    metadata: other.metadata,
+                    stateVersion: 1,
+                }, this.replicaId));
+                localChanged = true;
+            }
+            entriesMerged++;
+        }
+        // Merge vector clock
+        const otherClock = VectorClock_1.VectorClock.fromSerialized(other.vectorClock, this.replicaId);
+        this.vectorClock.merge(otherClock);
+        // Update metadata
+        this.crdtMetadata.mergeCount++;
+        this.crdtMetadata.updatedAt = Date.now();
+        if (localChanged) {
+            this.crdtMetadata.lastModifiedBy = other.origin;
+        }
+        const stats = {
+            duration: Date.now() - startTime,
+            entriesMerged,
+            autoResolved: allConflicts.length,
+            tombstonesProcessed: tagsResult.stats.tombstonesProcessed,
+            memoryDelta: entriesMerged * 32,
+        };
+        return {
+            success: true,
+            mergedState: this.state(),
+            localChanged,
+            conflicts: allConflicts,
+            stats,
+        };
+    }
+    // ============================================
+    // Delta Operations
+    // ============================================
+    /**
+     * Generate a delta update since the last sync
+     *
+     * @param since - Vector clock of last sync
+     * @returns Delta update or null if no changes
+     */
+    generateDelta(since) {
+        const sinceClock = since
+            ? VectorClock_1.VectorClock.fromSerialized(since, this.replicaId)
+            : this.lastDeltaClock;
+        if (!this.vectorClock.happenedAfter(sinceClock) &&
+            !this.vectorClock.isConcurrent(sinceClock)) {
+            return null;
+        }
+        const operations = [];
+        // Generate a full state delta for simplicity
+        // In production, you'd want to track individual field changes
+        operations.push({
+            op: types_1.DeltaOpType.Set,
+            value: this.state().value,
+            replica: this.replicaId,
+        });
+        const delta = {
+            crdtId: this.id,
+            type: types_1.CRDTType.PatternCRDT,
+            origin: this.replicaId,
+            vectorClock: this.vectorClock.serialize(),
+            operations,
+            sequenceNumber: this.sequenceNumber,
+            generatedAt: Date.now(),
+        };
+        this.lastDeltaClock = this.vectorClock.clone();
+        return delta;
+    }
+    /**
+     * Apply a delta update
+     *
+     * @param delta - Delta to apply
+     * @returns True if applied successfully
+     */
+    applyDelta(delta) {
+        if (delta.type !== types_1.CRDTType.PatternCRDT) {
+            return false;
+        }
+        if (delta.crdtId !== this.id) {
+            return false;
+        }
+        let changed = false;
+        for (const op of delta.operations) {
+            if (op.op === types_1.DeltaOpType.Set && op.value) {
+                // Apply as full state merge
+                const result = this.merge({
+                    type: types_1.CRDTType.PatternCRDT,
+                    id: this.id,
+                    vectorClock: delta.vectorClock,
+                    origin: delta.origin,
+                    value: op.value,
+                    metadata: this.crdtMetadata,
+                    stateVersion: 1,
+                });
+                if (result.localChanged) {
+                    changed = true;
+                }
+            }
+        }
+        return changed;
+    }
+    // ============================================
+    // Utility Methods
+    // ============================================
+    /**
+     * Create a deep copy
+     *
+     * @returns Cloned PatternCRDT
+     */
+    clone() {
+        return PatternCRDT.fromState(this.state(), this.replicaId);
+    }
+    /**
+     * Get the replica ID
+     *
+     * @returns Replica ID
+     */
+    getReplicaId() {
+        return this.replicaId;
+    }
+    /**
+     * Get the vector clock
+     *
+     * @returns Vector clock copy
+     */
+    getVectorClock() {
+        return this.vectorClock.clone();
+    }
+    /**
+     * Get CRDT metadata
+     *
+     * @returns Metadata copy
+     */
+    getCRDTMetadata() {
+        return { ...this.crdtMetadata };
+    }
+    /**
+     * String representation
+     *
+     * @returns Debug string
+     */
+    toString() {
+        return `PatternCRDT{id=${this.id}, type=${this.getType()}, tags=${this.tags.size()}, usage=${this.usageCount.value()}}`;
+    }
+}
+exports.PatternCRDT = PatternCRDT;
+//# sourceMappingURL=PatternCRDT.js.map