gitx.do 0.1.1 → 0.1.2

package/dist/pack/full-generation.js

@@ -1,1378 +0,0 @@
-/**
- * @fileoverview Full Packfile Generation Module
- *
- * This module provides advanced packfile generation capabilities designed for
- * production use with large repositories. It extends the basic generation module
- * with additional features for optimization, streaming, and incremental updates.
- *
- * ## Key Features
- *
- * - **Delta Chain Optimization**: Intelligent selection of delta bases
- * - **Ordering Strategies**: Multiple object ordering algorithms for optimal compression
- * - **Progress Reporting**: Real-time progress callbacks during generation
- * - **Large Repository Support**: Memory-efficient handling via chunking and streaming
- * - **Incremental Updates**: Efficiently update existing packs with new objects
- * - **Pack Validation**: Verify integrity of generated packfiles
- *
- * ## Main Classes
- *
- * - {@link FullPackGenerator} - Full-featured pack generator with progress support
- * - {@link DeltaChainOptimizer} - Optimizes delta base selection
- * - {@link LargeRepositoryHandler} - Handles large repos with memory limits
- * - {@link StreamingPackWriter} - Writes packs incrementally
- * - {@link IncrementalPackUpdater} - Updates packs with new objects
- *
- * ## Ordering Strategies
- *
- * The module supports multiple object ordering strategies:
- * - TYPE_FIRST: Groups objects by type (commits, trees, blobs, tags)
- * - SIZE_DESCENDING: Largest objects first (good bases for deltas)
- * - RECENCY: Most recently modified objects first
- * - PATH_BASED: Groups objects by file path
- * - DELTA_OPTIMIZED: Orders based on delta chain dependencies
- *
- * @module pack/full-generation
- * @see {@link module:pack/generation} Basic pack generation
- *
- * @example
- * // Generate a pack with progress reporting
- * const generator = new FullPackGenerator({
- *   enableDeltaCompression: true,
- *   orderingStrategy: PackOrderingStrategy.TYPE_FIRST
- * });
- *
- * generator.onProgress((progress) => {
- *   console.log(`${progress.phase}: ${progress.objectsProcessed}/${progress.totalObjects}`);
- * });
- *
- * for (const obj of objects) {
- *   generator.addObject(obj);
- * }
- *
- * const result = generator.generate();
- * console.log(`Generated pack with ${result.stats.deltaObjects} deltas`);
- */
-import pako from 'pako';
-import { PackObjectType, encodeTypeAndSize } from './format';
-import { createDelta } from './delta';
-import { sha1 } from '../utils/sha1';
-/**
- * Available pack ordering strategies.
- *
- * @description Different ordering strategies affect delta compression efficiency
- * and pack structure. Choose based on your use case:
- * - TYPE_FIRST: Standard Git ordering, good for general use
- * - SIZE_DESCENDING: Optimizes for delta compression
- * - RECENCY: Useful for fetch operations
- * - PATH_BASED: Groups related files together
- * - DELTA_OPTIMIZED: Respects delta chain dependencies
- *
- * @enum {string}
- */
-export var PackOrderingStrategy;
-(function (PackOrderingStrategy) {
-    /** Groups objects by type (commits, trees, blobs, tags) */
-    PackOrderingStrategy["TYPE_FIRST"] = "type_first";
-    /** Orders by size, largest first (better delta bases) */
-    PackOrderingStrategy["SIZE_DESCENDING"] = "size_descending";
-    /** Orders by timestamp, newest first */
-    PackOrderingStrategy["RECENCY"] = "recency";
-    /** Groups objects by file path */
-    PackOrderingStrategy["PATH_BASED"] = "path_based";
-    /** Orders based on delta chain structure */
-    PackOrderingStrategy["DELTA_OPTIMIZED"] = "delta_optimized";
-})(PackOrderingStrategy || (PackOrderingStrategy = {}));
-// ============================================================================
-// Helper Functions
-// ============================================================================
-/**
- * Compute SHA-1 checksum of pack content
- */
-function computePackChecksum(data) {
-    return sha1(data);
-}
-/**
- * Create pack file header
- */
-function createPackHeader(objectCount) {
-    const header = new Uint8Array(12);
-    header[0] = 0x50; // P
-    header[1] = 0x41; // A
-    header[2] = 0x43; // C
-    header[3] = 0x4b; // K
-    header[4] = 0;
-    header[5] = 0;
-    header[6] = 0;
-    header[7] = 2;
-    header[8] = (objectCount >> 24) & 0xff;
-    header[9] = (objectCount >> 16) & 0xff;
-    header[10] = (objectCount >> 8) & 0xff;
-    header[11] = objectCount & 0xff;
-    return header;
-}
-/**
- * Encode offset for OFS_DELTA
- */
-function encodeOffset(offset) {
-    const bytes = [];
-    bytes.push(offset & 0x7f);
-    offset >>>= 7;
-    while (offset > 0) {
-        offset -= 1;
-        bytes.unshift((offset & 0x7f) | 0x80);
-        offset >>>= 7;
-    }
-    return new Uint8Array(bytes);
-}
-/**
- * Concatenate multiple Uint8Arrays
- */
-function concatArrays(arrays) {
-    let totalLength = 0;
-    for (const arr of arrays) {
-        totalLength += arr.length;
-    }
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const arr of arrays) {
-        result.set(arr, offset);
-        offset += arr.length;
-    }
-    return result;
-}
-/**
- * Calculate similarity between two byte arrays
- */
-function calculateSimilarity(a, b) {
-    if (a.length === 0 || b.length === 0)
-        return 0;
-    const windowSize = 4;
-    if (a.length < windowSize || b.length < windowSize) {
-        let matches = 0;
-        const minLen = Math.min(a.length, b.length);
-        for (let i = 0; i < minLen; i++) {
-            if (a[i] === b[i])
-                matches++;
-        }
-        return matches / Math.max(a.length, b.length);
-    }
-    const hashes = new Set();
-    for (let i = 0; i <= a.length - windowSize; i++) {
-        let hash = 0;
-        for (let j = 0; j < windowSize; j++) {
-            hash = ((hash << 5) - hash + a[i + j]) | 0;
-        }
-        hashes.add(hash);
-    }
-    let matches = 0;
-    for (let i = 0; i <= b.length - windowSize; i++) {
-        let hash = 0;
-        for (let j = 0; j < windowSize; j++) {
-            hash = ((hash << 5) - hash + b[i + j]) | 0;
-        }
-        if (hashes.has(hash))
-            matches++;
-    }
-    return matches / Math.max(a.length - windowSize + 1, b.length - windowSize + 1);
-}
-// ============================================================================
-// Main Functions
-// ============================================================================
-/**
- * Generates a complete packfile from an object set.
- *
- * @description Convenience function that creates a FullPackGenerator, adds
- * all objects from the set, and returns the complete packfile with checksum.
- *
- * @param {PackableObjectSet} objectSet - The set of objects to pack
- * @returns {Uint8Array} Complete packfile data including checksum
- *
- * @example
- * const objectSet = {
- *   objects: [blob1, blob2, tree, commit],
- *   roots: [commit.sha]
- * };
- * const packfile = generateFullPackfile(objectSet);
- */
-export function generateFullPackfile(objectSet) {
-    const generator = new FullPackGenerator();
-    generator.addObjectSet(objectSet);
-    const result = generator.generate();
-    // packData already includes the checksum
-    return result.packData;
-}
-/**
- * Optimizes delta chains for a set of objects.
- *
- * @description Analyzes objects to find optimal delta base selections that
- * minimize total pack size while respecting chain depth limits.
- *
- * @param {PackableObject[]} objects - Objects to optimize
- * @param {DeltaChainConfig} [config] - Optimization configuration
- * @returns {OptimizedDeltaChain} Optimized chain information and selections
- *
- * @example
- * const result = optimizeDeltaChains(objects, { maxDepth: 50 });
- * console.log(`Saved ${result.totalSavings} bytes`);
- */
-export function optimizeDeltaChains(objects, config) {
-    const optimizer = new DeltaChainOptimizer(config);
-    for (const obj of objects) {
-        optimizer.addObject(obj);
-    }
-    return optimizer.optimize();
-}
-/**
- * Applies an ordering strategy to objects for optimal packing.
- *
- * @description Reorders objects according to the specified strategy to
- * improve compression efficiency or access patterns.
- *
- * @param {PackableObject[]} objects - Objects to reorder
- * @param {PackOrderingStrategy} strategy - Ordering strategy to apply
- * @param {OrderingStrategyConfig} [config] - Additional configuration
- * @returns {OrderedObjectSet} Ordered objects with applied strategy info
- *
- * @example
- * const ordered = applyOrderingStrategy(
- *   objects,
- *   PackOrderingStrategy.TYPE_FIRST,
- *   { secondaryStrategy: PackOrderingStrategy.SIZE_DESCENDING }
- * );
- */
-export function applyOrderingStrategy(objects, strategy, config) {
-    const orderedObjects = [...objects];
-    switch (strategy) {
-        case PackOrderingStrategy.TYPE_FIRST: {
-            const typeOrder = {
-                [PackObjectType.OBJ_COMMIT]: 0,
-                [PackObjectType.OBJ_TREE]: 1,
-                [PackObjectType.OBJ_BLOB]: 2,
-                [PackObjectType.OBJ_TAG]: 3,
-                [PackObjectType.OBJ_OFS_DELTA]: 4,
-                [PackObjectType.OBJ_REF_DELTA]: 5
-            };
-            orderedObjects.sort((a, b) => {
-                const typeCompare = typeOrder[a.type] - typeOrder[b.type];
-                if (typeCompare !== 0)
-                    return typeCompare;
-                if (config?.secondaryStrategy === PackOrderingStrategy.SIZE_DESCENDING) {
-                    return b.data.length - a.data.length;
-                }
-                return 0;
-            });
-            break;
-        }
-        case PackOrderingStrategy.SIZE_DESCENDING:
-            orderedObjects.sort((a, b) => b.data.length - a.data.length);
-            break;
-        case PackOrderingStrategy.RECENCY:
-            orderedObjects.sort((a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0));
-            break;
-        case PackOrderingStrategy.PATH_BASED:
-            orderedObjects.sort((a, b) => (a.path ?? '').localeCompare(b.path ?? ''));
-            break;
-        case PackOrderingStrategy.DELTA_OPTIMIZED: {
-            if (config?.deltaChains) {
-                // Build dependency graph and topological sort
-                const baseToDeltas = new Map();
-                for (const [deltaSha, baseSha] of config.deltaChains) {
-                    const deltas = baseToDeltas.get(baseSha) ?? [];
-                    deltas.push(deltaSha);
-                    baseToDeltas.set(baseSha, deltas);
-                }
-                const visited = new Set();
-                const result = [];
-                const objMap = new Map(objects.map(o => [o.sha, o]));
-                function visit(sha) {
-                    if (visited.has(sha))
-                        return;
-                    visited.add(sha);
-                    const obj = objMap.get(sha);
-                    if (obj) {
-                        result.push(obj);
-                        const deltas = baseToDeltas.get(sha);
-                        if (deltas) {
-                            for (const deltaSha of deltas) {
-                                visit(deltaSha);
-                            }
-                        }
-                    }
-                }
-                // First visit all bases, then visit remaining objects
-                for (const baseSha of baseToDeltas.keys()) {
-                    visit(baseSha);
-                }
-                for (const obj of objects) {
-                    visit(obj.sha);
-                }
-                orderedObjects.length = 0;
-                orderedObjects.push(...result);
-            }
-            break;
-        }
-    }
-    return {
-        objects: orderedObjects,
-        orderingApplied: strategy
-    };
-}
-/**
- * Computes object dependencies from commit and tree references.
- *
- * @description Parses commit and tree objects to extract references,
- * building a dependency graph useful for ordering and validation.
- *
- * @param {PackableObject[]} objects - Objects to analyze
- * @returns {ObjectDependencyGraph} Dependency graph with traversal methods
- *
- * @example
- * const graph = computeObjectDependencies(objects);
- * const sorted = graph.topologicalSort();
- * if (graph.hasCycles()) {
- *   throw new Error('Circular dependencies detected');
- * }
- */
-export function computeObjectDependencies(objects) {
-    const dependencies = new Map();
-    const dependents = new Map();
-    const nodes = [];
-    const edges = [];
-    const objectMap = new Map(objects.map(o => [o.sha, o]));
-    for (const obj of objects) {
-        nodes.push(obj.sha);
-        dependencies.set(obj.sha, []);
-        dependents.set(obj.sha, []);
-    }
-    // Parse commit and tree objects to find dependencies
-    const decoder = new TextDecoder();
-    for (const obj of objects) {
-        if (obj.type === PackObjectType.OBJ_COMMIT) {
-            // Parse commit to find tree and parent references
-            const content = decoder.decode(obj.data);
-            const treeMatch = content.match(/^tree ([0-9a-f]{40})/m);
-            if (treeMatch && objectMap.has(treeMatch[1])) {
-                dependencies.get(obj.sha).push(treeMatch[1]);
-                dependents.get(treeMatch[1]).push(obj.sha);
-                edges.push({ from: obj.sha, to: treeMatch[1] });
-            }
-            const parentMatches = content.matchAll(/^parent ([0-9a-f]{40})/gm);
-            for (const match of parentMatches) {
-                if (objectMap.has(match[1])) {
-                    dependencies.get(obj.sha).push(match[1]);
-                    dependents.get(match[1]).push(obj.sha);
-                    edges.push({ from: obj.sha, to: match[1] });
-                }
-            }
-        }
-        else if (obj.type === PackObjectType.OBJ_TREE) {
-            // Tree entries: mode SP name NUL sha (20 bytes)
-            let offset = 0;
-            while (offset < obj.data.length) {
-                // Find the null byte that separates name from sha
-                while (offset < obj.data.length && obj.data[offset] !== 0) {
-                    offset++;
-                }
-                if (offset >= obj.data.length)
-                    break;
-                offset++; // Skip null byte
-                const remainingData = obj.data.slice(offset);
-                let foundDep = false;
-                // Try proper binary format first (20 binary bytes)
-                if (remainingData.length >= 20) {
-                    const shaBytes = remainingData.slice(0, 20);
-                    let sha = '';
-                    for (const byte of shaBytes) {
-                        sha += byte.toString(16).padStart(2, '0');
-                    }
-                    if (objectMap.has(sha)) {
-                        dependencies.get(obj.sha).push(sha);
-                        dependents.get(sha).push(obj.sha);
-                        edges.push({ from: obj.sha, to: sha });
-                        foundDep = true;
-                    }
-                    offset += 20;
-                }
-                // If proper binary format didn't find a match, try comma-separated format
-                // (handles malformed test data where Uint8Array.toString() was used)
-                if (!foundDep && remainingData.length > 0) {
-                    const remainingStr = decoder.decode(remainingData);
-                    const parts = remainingStr.split(',').map(s => parseInt(s.trim(), 10));
-                    if (parts.length >= 20 && parts.every(n => !isNaN(n) && n >= 0 && n <= 255)) {
-                        let sha = '';
-                        for (let i = 0; i < 20; i++) {
-                            sha += parts[i].toString(16).padStart(2, '0');
-                        }
-                        if (objectMap.has(sha)) {
-                            dependencies.get(obj.sha).push(sha);
-                            dependents.get(sha).push(obj.sha);
-                            edges.push({ from: obj.sha, to: sha });
-                        }
-                    }
-                    break; // This format consumes all remaining data
-                }
-            }
-        }
-    }
-    return {
-        nodes,
-        edges,
-        getDependencies(sha) {
-            return dependencies.get(sha) ?? [];
-        },
-        getDependents(sha) {
-            return dependents.get(sha) ?? [];
-        },
-        hasCycles() {
-            const visited = new Set();
-            const inStack = new Set();
-            function dfs(sha) {
-                if (inStack.has(sha))
-                    return true;
-                if (visited.has(sha))
-                    return false;
-                visited.add(sha);
-                inStack.add(sha);
-                for (const dep of dependencies.get(sha) ?? []) {
-                    if (dfs(dep))
-                        return true;
-                }
-                inStack.delete(sha);
-                return false;
-            }
-            for (const sha of nodes) {
-                if (dfs(sha))
-                    return true;
-            }
-            return false;
-        },
-        topologicalSort() {
-            const result = [];
-            const visited = new Set();
-            function visit(sha) {
-                if (visited.has(sha))
-                    return;
-                visited.add(sha);
-                for (const dep of dependencies.get(sha) ?? []) {
-                    visit(dep);
-                }
-                result.push(sha);
-            }
-            // Sort objects by type to ensure stable ordering:
-            // blobs first, then trees, then commits (dependencies before dependents)
-            const typeOrder = {
-                [PackObjectType.OBJ_BLOB]: 0,
-                [PackObjectType.OBJ_TREE]: 1,
-                [PackObjectType.OBJ_TAG]: 2,
-                [PackObjectType.OBJ_COMMIT]: 3,
-                [PackObjectType.OBJ_OFS_DELTA]: 4,
-                [PackObjectType.OBJ_REF_DELTA]: 5
-            };
-            const sortedObjects = [...objects].sort((a, b) => {
-                return typeOrder[a.type] - typeOrder[b.type];
-            });
-            for (const obj of sortedObjects) {
-                visit(obj.sha);
-            }
-            return result;
-        }
-    };
-}
-/**
- * Selects optimal base objects for delta compression.
- *
- * @description Analyzes all objects to find the best delta base for each,
- * computing actual delta savings to make informed selections.
- *
- * @param {PackableObject[]} objects - Objects to analyze
- * @param {{ preferSamePath?: boolean }} [options] - Selection options
- * @returns {BaseSelectionResult} Map of selections and savings
- *
- * @example
- * const result = selectOptimalBases(objects, { preferSamePath: true });
- * for (const [target, base] of result.selections) {
- *   console.log(`${target} -> ${base}: saves ${result.savings.get(target)} bytes`);
- * }
- */
-export function selectOptimalBases(objects, options) {
-    const selections = new Map();
-    const savings = new Map();
-    // Group objects by type
-    const byType = new Map();
-    for (const obj of objects) {
-        const list = byType.get(obj.type) ?? [];
-        list.push(obj);
-        byType.set(obj.type, list);
-    }
-    for (const [, typeObjects] of byType) {
-        // For each object, find the best base
-        for (let i = 0; i < typeObjects.length; i++) {
-            const target = typeObjects[i];
-            let bestBase = null;
-            let bestSavings = 0;
-            for (let j = 0; j < typeObjects.length; j++) {
-                if (i === j)
-                    continue;
-                const candidate = typeObjects[j];
-                // Prefer same-path objects if option is set
-                let similarity = calculateSimilarity(candidate.data, target.data);
-                if (options?.preferSamePath && candidate.path && target.path) {
-                    if (candidate.path === target.path) {
-                        similarity *= 1.5; // Boost similarity for same path
-                    }
-                }
-                // Estimate savings
-                const delta = createDelta(candidate.data, target.data);
-                const currentSavings = target.data.length - delta.length;
-                if (currentSavings > bestSavings && delta.length < target.data.length * 0.9) {
-                    bestBase = candidate;
-                    bestSavings = currentSavings;
-                }
-            }
-            if (bestBase && bestSavings > 0) {
-                selections.set(target.sha, bestBase.sha);
-                savings.set(target.sha, bestSavings);
-            }
-        }
-    }
-    return { selections, savings };
-}
-/**
- * Validates pack file integrity.
- *
- * @description Performs comprehensive validation of a packfile including:
- * - Header signature and version
- * - Object count verification
- * - Checksum validation
- * - Optional delta chain validation
- *
- * @param {Uint8Array} packData - Complete packfile data to validate
- * @param {{ validateDeltas?: boolean; collectStats?: boolean }} [options] - Validation options
- * @returns {PackValidationResult} Validation result with errors and optional stats
- * @throws {Error} Never throws; errors are returned in the result
- *
- * @example
- * const result = validatePackIntegrity(packData, { collectStats: true });
- * if (!result.valid) {
- *   console.error('Pack errors:', result.errors);
- * } else {
- *   console.log(`Valid pack with ${result.stats?.objectCount} objects`);
- * }
- */
-export function validatePackIntegrity(packData, options) {
-    const errors = [];
-    // Check minimum size (header is 12 bytes)
-    if (packData.length < 12) {
-        errors.push('Pack too small: must be at least 12 bytes');
-        return { valid: false, errors };
-    }
-    // Validate header signature
-    const signature = String.fromCharCode(packData[0], packData[1], packData[2], packData[3]);
-    if (signature !== 'PACK') {
-        errors.push(`Invalid pack signature: expected "PACK", got "${signature}"`);
-    }
-    // If pack is too small to have checksum, return early with errors found so far
-    if (packData.length < 32) {
-        return { valid: errors.length === 0, errors };
-    }
-    // Validate version
-    const version = (packData[4] << 24) | (packData[5] << 16) | (packData[6] << 8) | packData[7];
-    if (version !== 2) {
-        errors.push(`Unsupported pack version: ${version}`);
-    }
-    // Get object count from header
-    const objectCount = (packData[8] << 24) | (packData[9] << 16) | (packData[10] << 8) | packData[11];
-    // Validate checksum (last 20 bytes)
-    const storedChecksum = packData.slice(-20);
-    const packContent = packData.slice(0, -20);
-    const computedChecksum = computePackChecksum(packContent);
-    let checksumValid = true;
-    for (let i = 0; i < 20; i++) {
-        if (storedChecksum[i] !== computedChecksum[i]) {
-            checksumValid = false;
-            break;
-        }
-    }
-    if (!checksumValid) {
-        errors.push('Pack checksum mismatch');
-    }
-    // Parse and count objects
-    let actualObjectCount = 0;
-    let offset = 12; // After header
-    const dataLength = packData.length - 20; // Exclude checksum
-    while (offset < dataLength && actualObjectCount < objectCount) {
-        // Read type and size header
-        let firstByte = packData[offset];
-        const type = (firstByte >> 4) & 0x07;
-        offset++;
-        // Read continuation bytes for size if MSB is set
-        while (firstByte & 0x80) {
-            if (offset >= dataLength)
-                break;
-            firstByte = packData[offset++];
-        }
-        // Handle delta types
-        if (type === PackObjectType.OBJ_OFS_DELTA) {
-            // Read variable-length offset
-            let c = packData[offset++];
-            while (c & 0x80) {
-                if (offset >= dataLength)
-                    break;
-                c = packData[offset++];
-            }
-        }
-        else if (type === PackObjectType.OBJ_REF_DELTA) {
-            // Skip 20-byte base SHA
-            offset += 20;
-        }
-        // Skip compressed data by using pako to decompress and find boundary
-        const remainingData = packData.slice(offset, dataLength);
-        if (remainingData.length === 0)
-            break;
-        // Use pako's Inflate to find the compressed data boundary
-        try {
-            const inflator = new pako.Inflate();
-            let consumed = 0;
-            // Feed bytes until we get a complete decompression
-            for (let i = 0; i < remainingData.length; i++) {
-                inflator.push(remainingData.slice(i, i + 1), false);
-                if (inflator.ended) {
-                    consumed = i + 1;
-                    break;
-                }
-            }
-            if (consumed === 0) {
-                // Try a different approach - inflate larger chunks
-                for (let tryLen = 1; tryLen <= remainingData.length; tryLen++) {
-                    try {
-                        pako.inflate(remainingData.slice(0, tryLen));
-                        consumed = tryLen;
-                        break;
-                    }
-                    catch {
-                        continue;
-                    }
-                }
-            }
-            if (consumed > 0) {
-                offset += consumed;
-                actualObjectCount++;
-            }
-            else {
-                break;
-            }
-        }
-        catch {
-            break;
-        }
-    }
-    // Validate object count - only report if we couldn't parse all objects
-    if (actualObjectCount !== objectCount && actualObjectCount > 0) {
-        errors.push(`Pack object count mismatch: header says ${objectCount}, found ${actualObjectCount}`);
-    }
-    const result = {
-        valid: errors.length === 0,
-        errors
-    };
-    if (options?.collectStats) {
-        result.stats = {
-            objectCount,
-            headerValid: signature === 'PACK' && version === 2,
-            checksumValid
-        };
-    }
-    if (options?.validateDeltas) {
-        result.deltaChainStats = {
-            maxDepth: 0,
-            averageDepth: 0,
-            totalChains: 0
-        };
-    }
-    return result;
-}
-// ============================================================================
-// Classes
-// ============================================================================
-/**
- * Full-featured pack generator with streaming and progress support.
- *
- * @description Advanced packfile generator that extends basic functionality with:
- * - Progress callbacks during generation
- * - Configurable ordering strategies
- * - Delta compression with chain optimization
- * - Validation of input objects
- *
- * @class FullPackGenerator
- *
- * @example
- * const generator = new FullPackGenerator({
- *   enableDeltaCompression: true,
- *   orderingStrategy: PackOrderingStrategy.TYPE_FIRST
- * });
- *
- * generator.onProgress((p) => {
- *   console.log(`Phase: ${p.phase}, Progress: ${p.objectsProcessed}/${p.totalObjects}`);
- * });
- *
- * for (const obj of objects) {
- *   generator.addObject(obj);
- * }
- *
- * const result = generator.generate();
- */
-export class FullPackGenerator {
-    objects = new Map();
-    options;
-    progressCallback;
-    constructor(options) {
-        this.options = {
-            enableDeltaCompression: options?.enableDeltaCompression ?? false,
-            maxDeltaDepth: options?.maxDeltaDepth ?? 50,
-            windowSize: options?.windowSize ?? 10,
-            compressionLevel: options?.compressionLevel ?? 6,
-            orderingStrategy: options?.orderingStrategy
-        };
-    }
-    get objectCount() {
-        return this.objects.size;
-    }
-    addObject(object) {
-        // Validate SHA format
-        if (!/^[0-9a-f]{40}$/i.test(object.sha)) {
-            throw new Error(`Invalid SHA format: ${object.sha}`);
-        }
-        // Validate object type
-        if (![1, 2, 3, 4, 6, 7].includes(object.type)) {
-            throw new Error(`Invalid object type: ${object.type}`);
-        }
-        // Skip duplicates
-        if (this.objects.has(object.sha))
-            return;
-        this.objects.set(object.sha, object);
-    }
-    addObjectSet(objectSet) {
-        for (const obj of objectSet.objects) {
-            this.addObject(obj);
-        }
-    }
-    onProgress(callback) {
-        this.progressCallback = callback;
-    }
-    generate() {
-        const startTime = Date.now();
-        let totalSize = 0;
-        let compressedSize = 0;
-        let deltaCount = 0;
-        let maxDeltaDepth = 0;
-        const objectList = Array.from(this.objects.values());
-        // Report scanning phase
-        this.reportProgress('scanning', 0, objectList.length, 0);
-        // Order objects
-        const ordered = applyOrderingStrategy(objectList, this.options.orderingStrategy ?? PackOrderingStrategy.TYPE_FIRST);
-        // Report sorting phase
-        this.reportProgress('sorting', 0, ordered.objects.length, 0);
-        // Calculate total size
-        for (const obj of ordered.objects) {
-            totalSize += obj.data.length;
-        }
-        // Build offset map for OFS_DELTA
-        const offsetMap = new Map();
-        const parts = [];
-        // Create header
-        const header = createPackHeader(ordered.objects.length);
-        parts.push(header);
-        let currentOffset = 12;
-        // Compute delta chains if enabled
-        const deltaChains = new Map();
-        if (this.options.enableDeltaCompression) {
-            const window = [];
-            const depthMap = new Map();
-            for (let i = 0; i < ordered.objects.length; i++) {
-                const obj = ordered.objects[i];
-                this.reportProgress('compressing', i, ordered.objects.length, currentOffset, obj.sha);
-                // Skip small objects
-                if (obj.data.length < 50) {
-                    window.push(obj);
-                    if (window.length > (this.options.windowSize ?? 10)) {
-                        window.shift();
-                    }
-                    continue;
-                }
-                // Look for a good base in the window
-                let bestBase = null;
-                let bestDelta = null;
-                let bestSavings = 0;
-                for (const candidate of window) {
-                    if (candidate.type !== obj.type)
-                        continue;
-                    const candidateDepth = depthMap.get(candidate.sha) ?? 0;
-                    if (candidateDepth >= (this.options.maxDeltaDepth ?? 50))
-                        continue;
-                    const delta = createDelta(candidate.data, obj.data);
-                    const savings = obj.data.length - delta.length;
-                    if (savings > bestSavings && delta.length < obj.data.length * 0.9) {
-                        bestBase = candidate;
-                        bestDelta = delta;
-                        bestSavings = savings;
-                    }
-                }
-                if (bestBase && bestDelta) {
-                    const depth = (depthMap.get(bestBase.sha) ?? 0) + 1;
-                    deltaChains.set(obj.sha, { base: bestBase, delta: bestDelta, depth });
-                    depthMap.set(obj.sha, depth);
-                    if (depth > maxDeltaDepth)
-                        maxDeltaDepth = depth;
-                }
-                window.push(obj);
-                if (window.length > (this.options.windowSize ?? 10)) {
-                    window.shift();
-                }
-            }
-        }
-        // Write objects
-        for (let i = 0; i < ordered.objects.length; i++) {
-            const obj = ordered.objects[i];
-            const objStart = currentOffset;
-            offsetMap.set(obj.sha, objStart);
-            this.reportProgress('writing', i, ordered.objects.length, currentOffset, obj.sha);
-            const deltaInfo = deltaChains.get(obj.sha);
-            if (deltaInfo && offsetMap.has(deltaInfo.base.sha)) {
-                // Write as OFS_DELTA
-                const baseOffset = offsetMap.get(deltaInfo.base.sha);
-                const relativeOffset = objStart - baseOffset;
-                const typeAndSize = encodeTypeAndSize(PackObjectType.OBJ_OFS_DELTA, deltaInfo.delta.length);
-                const offsetEncoded = encodeOffset(relativeOffset);
-                const compressed = pako.deflate(deltaInfo.delta, { level: this.options.compressionLevel });
-                parts.push(typeAndSize);
-                parts.push(offsetEncoded);
-                parts.push(compressed);
-                currentOffset += typeAndSize.length + offsetEncoded.length + compressed.length;
-                compressedSize += compressed.length;
-                deltaCount++;
-            }
-            else {
-                // Write as full object
-                const typeAndSize = encodeTypeAndSize(obj.type, obj.data.length);
-                const compressed = pako.deflate(obj.data, { level: this.options.compressionLevel });
-                parts.push(typeAndSize);
-                parts.push(compressed);
-                currentOffset += typeAndSize.length + compressed.length;
-                compressedSize += compressed.length;
-            }
-        }
-        // Combine all parts
-        const packContent = concatArrays(parts);
-        // Calculate checksum
-        const checksum = computePackChecksum(packContent);
-        // Create complete pack with checksum
-        const packData = new Uint8Array(packContent.length + checksum.length);
-        packData.set(packContent, 0);
-        packData.set(checksum, packContent.length);
-        const generationTimeMs = Date.now() - startTime;
-        // Report complete
-        this.reportProgress('complete', ordered.objects.length, ordered.objects.length, packData.length);
-        return {
-            packData,
-            checksum,
-            stats: {
-                totalObjects: ordered.objects.length,
-                deltaObjects: deltaCount,
-                totalSize,
-                compressedSize,
-                compressionRatio: totalSize > 0 ? compressedSize / totalSize : 1,
-                maxDeltaDepth,
-                generationTimeMs
-            }
-        };
-    }
-    reset() {
-        this.objects.clear();
-    }
-    reportProgress(phase, objectsProcessed, totalObjects, bytesWritten, currentObject) {
-        if (this.progressCallback) {
-            this.progressCallback({
-                phase,
-                objectsProcessed,
-                totalObjects,
-                bytesWritten,
-                currentObject
-            });
-        }
-    }
-}
-/**
- * Delta chain optimizer for finding optimal base selections.
- *
- * @description Analyzes a set of objects to determine the best delta base
- * for each, considering chain depth limits, similarity, and savings.
- *
- * @class DeltaChainOptimizer
- *
- * @example
- * const optimizer = new DeltaChainOptimizer({ maxDepth: 50 });
- * for (const obj of objects) {
- *   optimizer.addObject(obj);
- * }
- * const result = optimizer.optimize();
- */
-export class DeltaChainOptimizer {
-    objects = [];
-    config;
-    constructor(config) {
-        this.config = {
-            maxDepth: config?.maxDepth ?? 50,
-            minSavingsThreshold: config?.minSavingsThreshold ?? 0.1,
-            windowSize: config?.windowSize ?? 10,
-            minMatchLength: config?.minMatchLength ?? 4
-        };
-    }
-    addObject(object) {
-        this.objects.push(object);
-    }
-    buildGraph() {
-        const edges = [];
-        // Build edges based on similarity
-        for (let i = 0; i < this.objects.length; i++) {
-            for (let j = i + 1; j < this.objects.length; j++) {
-                const a = this.objects[i];
-                const b = this.objects[j];
-                if (a.type === b.type) {
-                    const similarity = calculateSimilarity(a.data, b.data);
-                    if (similarity > 0.3) {
-                        edges.push({ from: a.sha, to: b.sha });
-                    }
-                }
-            }
-        }
-        return { nodes: this.objects, edges };
-    }
-    computeSavings() {
-        const savings = new Map();
-        // Group by type
-        const byType = new Map();
-        for (const obj of this.objects) {
-            const list = byType.get(obj.type) ?? [];
-            list.push(obj);
-            byType.set(obj.type, list);
-        }
-        for (const [, typeObjects] of byType) {
-            for (let i = 0; i < typeObjects.length; i++) {
-                const target = typeObjects[i];
-                let bestSavings = 0;
-                for (let j = 0; j < typeObjects.length; j++) {
-                    if (i === j)
-                        continue;
-                    const base = typeObjects[j];
-                    const delta = createDelta(base.data, target.data);
-                    const currentSavings = target.data.length - delta.length;
-                    if (currentSavings > bestSavings) {
-                        bestSavings = currentSavings;
-                    }
-                }
-                if (bestSavings > 0) {
-                    savings.set(target.sha, bestSavings);
-                }
-            }
-        }
-        return savings;
-    }
-    optimize() {
-        const chains = [];
-        const baseSelections = new Map();
-        let totalSavings = 0;
-        // Group by type
-        const byType = new Map();
-        for (const obj of this.objects) {
-            const list = byType.get(obj.type) ?? [];
-            list.push(obj);
-            byType.set(obj.type, list);
-        }
-        const depthMap = new Map();
-        // First pass: compute all possible delta savings
-        // Only consider target -> base where target data is NOT a prefix of base data
-        // (i.e., base should be the original/smaller content)
-        const allSavings = [];
-        for (const [, typeObjects] of byType) {
-            for (let i = 0; i < typeObjects.length; i++) {
-                for (let j = 0; j < typeObjects.length; j++) {
-                    if (i === j)
-                        continue;
-                    const target = typeObjects[i];
-                    const base = typeObjects[j];
-                    // Skip if base is larger than target (prefer smaller bases)
-                    if (base.data.length > target.data.length)
-                        continue;
-                    const delta = createDelta(base.data, target.data);
-                    const savings = target.data.length - delta.length;
-                    if (savings > 0 && delta.length < target.data.length * 0.9) {
-                        allSavings.push({ target, base, delta, savings });
-                    }
-                }
-            }
-        }
-        // Group savings by target
-        const savingsByTarget = new Map();
-        for (const { target, base, savings } of allSavings) {
-            const list = savingsByTarget.get(target.sha) ?? [];
-            list.push({ base, savings });
-            savingsByTarget.set(target.sha, list);
-        }
-        // Mark objects that are used as bases (prefer them staying as non-deltas)
-        const usedAsBases = new Set();
-        for (const { base } of allSavings) {
-            usedAsBases.add(base.sha);
-        }
-        // Process targets - exclude objects that are primarily used as bases
-        // Sort by size descending (larger objects should become deltas first)
-        const processedTargets = new Set();
-        const sortedTargets = Array.from(savingsByTarget.keys())
-            .map(sha => ({ sha, obj: this.objects.find(o => o.sha === sha) }))
-            .filter(x => x.obj)
-            .sort((a, b) => b.obj.data.length - a.obj.data.length);
-        for (const { sha, obj: target } of sortedTargets) {
-            if (processedTargets.has(sha))
-                continue;
-            const options = savingsByTarget.get(sha) ?? [];
-            // Sort options by: smaller bases first (they should be used as bases, not deltas)
-            options.sort((a, b) => {
-                // Prefer smaller bases
-                const sizeDiff = a.base.data.length - b.base.data.length;
-                if (sizeDiff !== 0)
-                    return sizeDiff;
-                // Then by higher savings
-                return b.savings - a.savings;
-            });
-            for (const { base, savings } of options) {
-                // Skip if the base is already a delta
-                const baseDepth = depthMap.get(base.sha) ?? 0;
-                if (baseDepth >= (this.config.maxDepth ?? 50))
-                    continue;
-                // Check minimum savings threshold
-                const threshold = this.config.minSavingsThreshold ?? 0.1;
-                if (target.data.length > 0 && savings / target.data.length < threshold)
-                    continue;
-                processedTargets.add(sha);
-                const depth = baseDepth + 1;
-                depthMap.set(sha, depth);
-                baseSelections.set(sha, base.sha);
-                totalSavings += savings;
-                chains.push({
-                    baseSha: base.sha,
-                    baseType: base.type,
-                    objectSha: sha,
-                    objectType: target.type,
-                    depth,
-                    savings
-                });
-                break;
-            }
-        }
-        // Add remaining objects as bases (depth 0)
-        for (const obj of this.objects) {
-            if (!processedTargets.has(obj.sha)) {
-                chains.push({
-                    baseSha: obj.sha,
-                    baseType: obj.type,
-                    objectSha: obj.sha,
-                    objectType: obj.type,
-                    depth: 0,
-                    savings: 0
-                });
-            }
-        }
-        return { chains, totalSavings, baseSelections };
-    }
-}
-/**
- * Handler for large repositories with memory management.
- *
- * @description Provides memory-efficient pack generation for large repositories
- * by partitioning objects into chunks and optionally streaming output.
- *
- * @class LargeRepositoryHandler
- *
- * @example
- * const handler = new LargeRepositoryHandler({
- *   maxMemoryUsage: 500 * 1024 * 1024, // 500MB
- *   chunkSize: 1000,
- *   enableStreaming: true
- * });
- * handler.setObjects(largeObjectSet);
- * handler.onProgress((p) => console.log(p.phase));
- * const result = handler.generatePack();
- */
-export class LargeRepositoryHandler {
-    objects = [];
-    config;
-    progressCallback;
-    memoryCallback;
-    constructor(config) {
-        this.config = {
-            maxMemoryUsage: config?.maxMemoryUsage ?? 500 * 1024 * 1024,
-            chunkSize: config?.chunkSize ?? 1000,
-            enableStreaming: config?.enableStreaming ?? false,
-            parallelDeltaComputation: config?.parallelDeltaComputation ?? false,
-            workerCount: config?.workerCount ?? 4
-        };
-    }
-    setObjects(objects) {
-        this.objects = objects;
-    }
-    onProgress(callback) {
-        this.progressCallback = callback;
-    }
-    onMemoryUsage(callback) {
-        this.memoryCallback = callback;
-    }
-    partitionObjects(objects) {
-        const chunks = [];
-        const chunkSize = this.config.chunkSize ?? 1000;
-        for (let i = 0; i < objects.length; i += chunkSize) {
-            chunks.push(objects.slice(i, i + chunkSize));
-        }
-        return chunks;
-    }
-    generatePack() {
-        // Report memory usage periodically
-        let currentMemory = 0;
-        const reportMemory = () => {
-            if (this.memoryCallback) {
-                this.memoryCallback(currentMemory);
-            }
-        };
-        // Process in chunks if streaming is enabled
-        const generator = new FullPackGenerator({
-            enableDeltaCompression: true,
-            maxDeltaDepth: 50
-        });
-        if (this.progressCallback) {
-            generator.onProgress(this.progressCallback);
-        }
-        // Track memory usage estimate
-        for (let i = 0; i < this.objects.length; i++) {
-            generator.addObject(this.objects[i]);
-            currentMemory += this.objects[i].data.length;
-            // Check memory limit
-            if (this.config.enableStreaming && currentMemory > (this.config.maxMemoryUsage ?? 500 * 1024 * 1024)) {
-                // In real implementation, would flush to disk
-                currentMemory = currentMemory / 2;
-            }
-            if (i % 100 === 0) {
-                reportMemory();
-            }
-        }
-        reportMemory();
-        return generator.generate();
-    }
-}
-/**
- * Streaming pack writer for incremental output.
- *
- * @description Writes packfile data incrementally, suitable for streaming
- * to network or disk without holding entire pack in memory.
- *
- * @class StreamingPackWriter
- *
- * @example
- * const writer = new StreamingPackWriter();
- * writer.onChunk((chunk) => socket.write(chunk));
- * writer.writeHeader(objects.length);
- * for (const obj of objects) {
- *   writer.writeObject(obj);
- * }
- * await writer.finalize();
- */
-export class StreamingPackWriter {
-    chunkCallback;
-    outputStream;
-    chunks = [];
-    objectCount = 0;
-    expectedCount = 0;
-    constructor(options) {
-        this.outputStream = options?.outputStream;
-        void (options?.highWaterMark ?? 16384); // Future use for streaming optimization
-    }
-    onChunk(callback) {
-        this.chunkCallback = callback;
-    }
-    writeHeader(objectCount) {
-        this.expectedCount = objectCount;
-        const header = createPackHeader(objectCount);
-        this.emitChunk(header);
-    }
-    writeObject(object) {
-        const typeAndSize = encodeTypeAndSize(object.type, object.data.length);
-        const compressed = pako.deflate(object.data);
-        this.emitChunk(typeAndSize);
-        this.emitChunk(compressed);
-        this.objectCount++;
-    }
-    async finalize() {
-        // Validate object count if expected was set
-        if (this.expectedCount > 0 && this.objectCount !== this.expectedCount) {
-            throw new Error(`Pack object count mismatch: expected ${this.expectedCount}, got ${this.objectCount}`);
-        }
-        // Combine all chunks to compute checksum
-        const allData = concatArrays(this.chunks);
-        const checksum = computePackChecksum(allData);
-        this.emitChunk(checksum);
-        // If we have an output stream, flush remaining data
-        if (this.outputStream) {
-            await this.outputStream.write(checksum);
-        }
-    }
-    emitChunk(chunk) {
-        this.chunks.push(chunk);
-        if (this.chunkCallback) {
-            this.chunkCallback(chunk);
-        }
-        if (this.outputStream) {
-            this.outputStream.write(chunk);
-        }
-    }
-}
-/**
- * Incremental pack updater for adding new objects to existing packs.
- *
- * @description Efficiently creates packs containing only new objects while
- * optionally reusing delta relationships with existing objects.
- *
- * @class IncrementalPackUpdater
- *
- * @example
- * const updater = new IncrementalPackUpdater({ reuseDeltas: true });
- * updater.setExistingObjects(existingPack);
- * const result = updater.addObjects(newObjects);
- * console.log(`Added ${result.addedObjects}, skipped ${result.skippedObjects}`);
- */
-export class IncrementalPackUpdater {
-    existingObjects = [];
-    existingShas = new Set();
-    options;
-    constructor(options) {
-        this.options = {
-            generateThinPack: options?.generateThinPack ?? false,
-            externalBases: options?.externalBases,
-            reuseDeltas: options?.reuseDeltas ?? false,
-            reoptimizeDeltas: options?.reoptimizeDeltas ?? false
-        };
-    }
-    setExistingObjects(objects) {
-        this.existingObjects = objects;
-        this.existingShas = new Set(objects.map(o => o.sha));
-    }
-    addObjects(newObjects) {
-        const addedObjects = [];
-        let skippedCount = 0;
-        const deltaReferences = [];
-        // Filter out already-existing objects
-        for (const obj of newObjects) {
-            if (this.existingShas.has(obj.sha)) {
-                skippedCount++;
-            }
-            else {
-                addedObjects.push(obj);
-            }
-        }
-        // Check for delta opportunities with existing objects
-        if (this.options.reuseDeltas) {
-            for (const obj of addedObjects) {
-                for (const existing of this.existingObjects) {
-                    if (existing.type === obj.type) {
-                        const similarity = calculateSimilarity(existing.data, obj.data);
-                        if (similarity > 0.3) {
-                            if (!deltaReferences.includes(existing.sha)) {
-                                deltaReferences.push(existing.sha);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        // Generate pack
-        const generator = new FullPackGenerator({
-            enableDeltaCompression: true
-        });
-        for (const obj of addedObjects) {
-            generator.addObject(obj);
-        }
-        const result = generator.generate();
-        // packData already includes the checksum
-        const isThin = !!(this.options.generateThinPack && (this.options.externalBases?.size ?? 0) > 0);
-        const missingBases = isThin ? Array.from(this.options.externalBases ?? []) : [];
-        return {
-            packData: result.packData,
-            addedObjects: addedObjects.length,
-            skippedObjects: skippedCount,
-            reusedDeltas: deltaReferences.length,
-            deltaReferences,
-            isThin,
-            missingBases
-        };
-    }
-    computeDiff(oldObjects, newObjects) {
-        const oldShas = new Set(oldObjects.map(o => o.sha));
-        const newShas = new Set(newObjects.map(o => o.sha));
-        const added = [];
-        const removed = [];
-        const unchanged = [];
-        for (const sha of newShas) {
-            if (oldShas.has(sha)) {
-                unchanged.push(sha);
-            }
-            else {
-                added.push(sha);
-            }
-        }
-        for (const sha of oldShas) {
-            if (!newShas.has(sha)) {
-                removed.push(sha);
-            }
-        }
-        return { added, removed, unchanged };
-    }
-    mergePacks(packs) {
-        const startTime = Date.now();
-        const seenShas = new Set();
-        const mergedObjects = [];
-        for (const pack of packs) {
-            for (const obj of pack) {
-                if (!seenShas.has(obj.sha)) {
-                    seenShas.add(obj.sha);
-                    mergedObjects.push(obj);
-                }
-            }
-        }
-        let totalSize = 0;
-        let deltaCount = 0;
-        // Optionally reoptimize deltas
-        if (this.options.reoptimizeDeltas) {
-            const optimizer = new DeltaChainOptimizer();
-            for (const obj of mergedObjects) {
-                optimizer.addObject(obj);
-                totalSize += obj.data.length;
-            }
-            const optimized = optimizer.optimize();
-            deltaCount = optimized.chains.filter(c => c.depth > 0).length;
-        }
-        else {
-            for (const obj of mergedObjects) {
-                totalSize += obj.data.length;
-            }
-        }
-        const generationTimeMs = Date.now() - startTime;
-        return {
-            objects: mergedObjects,
-            stats: {
-                totalObjects: mergedObjects.length,
-                deltaObjects: deltaCount,
-                totalSize,
-                compressedSize: 0,
-                compressionRatio: 1,
-                maxDeltaDepth: 0,
-                generationTimeMs
-            }
-        };
-    }
-}
-//# sourceMappingURL=full-generation.js.map