gitx.do 0.1.0 → 0.1.2

package/dist/tiered/cdc-pipeline.js

@@ -1,1880 +0,0 @@
-/**
- * @fileoverview CDC (Change Data Capture) Pipeline for Git Operations
- *
- * @description
- * This module provides a comprehensive Change Data Capture system for Git operations,
- * enabling real-time event streaming, transformation, and analytics for Git repository events.
- *
- * ## Key Features
- *
- * - **Event Capture**: Captures git operations (push, fetch, commits, branches, tags, merges)
- * - **Parquet Transformation**: Converts events to columnar Parquet format for analytics
- * - **Batching**: Efficient event batching with configurable size and time-based flushing
- * - **Retry Policies**: Configurable exponential backoff with jitter for resilient processing
- * - **Dead Letter Queue**: Handles failed events for later reprocessing
- * - **Metrics**: Built-in tracking for events processed, batches, errors, and latency
- *
- * ## Architecture
- *
- * The pipeline consists of several components:
- * 1. **CDCEventCapture**: Captures git operations and converts them to CDCEvents
- * 2. **CDCBatcher**: Batches events for efficient processing
- * 3. **ParquetTransformer**: Transforms events to Parquet format
- * 4. **CDCPipeline**: Orchestrates the entire flow with error handling
- *
- * ## Event Flow
- *
- * ```
- * Git Operation -> CDCEventCapture -> CDCBatcher -> ParquetTransformer -> Output
- *                                         |
- *                                         v
- *                              (On failure) Dead Letter Queue
- * ```
- *
- * @module tiered/cdc-pipeline
- *
- * @example
- * ```typescript
- * // Create and start a pipeline
- * const pipeline = new CDCPipeline({
- *   batchSize: 100,
- *   flushIntervalMs: 5000,
- *   maxRetries: 3,
- *   parquetCompression: 'snappy',
- *   outputPath: '/analytics',
- *   schemaVersion: 1
- * })
- *
- * await pipeline.start()
- *
- * // Process events
- * pipeline.onOutput((output) => {
- *   console.log(`Generated batch: ${output.batchId}`)
- *   console.log(`Events: ${output.events.length}`)
- *   console.log(`Parquet size: ${output.parquetBuffer.length} bytes`)
- * })
- *
- * pipeline.onDeadLetter((events, error) => {
- *   console.error(`Failed events: ${events.length}`, error)
- * })
- *
- * // Create and process an event
- * const event = createCDCEvent('COMMIT_CREATED', 'push', {
- *   operation: 'commit-create',
- *   sha: 'abc123...',
- *   treeSha: 'def456...',
- *   parentShas: ['parent1...']
- * })
- *
- * await pipeline.process(event)
- *
- * // Get metrics
- * const metrics = pipeline.getMetrics()
- * console.log(`Processed: ${metrics.eventsProcessed}`)
- * console.log(`Batches: ${metrics.batchesGenerated}`)
- *
- * // Stop the pipeline
- * await pipeline.stop()
- * ```
- *
- * @see {@link CDCPipeline} - Main pipeline orchestration class
- * @see {@link CDCEventCapture} - Event capture from git operations
- * @see {@link ParquetTransformer} - Parquet format transformation
- */
-// ============================================================================
-// Error Classes
-// ============================================================================
-/**
- * Custom error class for CDC operations.
- *
- * @description
- * CDCError provides structured error information for CDC pipeline failures,
- * including an error type for programmatic handling and optional cause for
- * error chaining.
- *
- * @example
- * ```typescript
- * try {
- *   await pipeline.process(event)
- * } catch (error) {
- *   if (error instanceof CDCError) {
- *     switch (error.type) {
- *       case 'VALIDATION_ERROR':
- *         console.log('Invalid event:', error.message)
- *         break
- *       case 'PROCESSING_ERROR':
- *         console.log('Processing failed:', error.message)
- *         if (error.cause) {
- *           console.log('Caused by:', error.cause.message)
- *         }
- *         break
- *     }
- *   }
- * }
- * ```
- *
- * @class CDCError
- * @extends Error
- */
-export class CDCError extends Error {
-    type;
-    cause;
-    /**
-     * Creates a new CDCError.
-     *
-     * @param type - Error type for categorization
-     * @param message - Human-readable error message
-     * @param cause - Optional underlying error that caused this error
-     */
-    constructor(type, message, cause) {
-        super(message);
-        this.type = type;
-        this.cause = cause;
-        this.name = 'CDCError';
-    }
-}
-/**
- * Retry policy implementing exponential backoff with optional jitter.
- *
- * @description
- * Provides a robust retry mechanism for handling transient failures.
- * Uses exponential backoff to space out retry attempts, with optional
- * jitter to prevent synchronized retries from multiple clients.
- *
- * **Backoff Formula:**
- * `delay = min(initialDelay * (multiplier ^ attempt), maxDelay)`
- *
- * **With Jitter:**
- * `delay = delay * random(0.5, 1.5)`
- *
- * @example
- * ```typescript
- * const policy = new CDCRetryPolicy({
- *   maxRetries: 3,
- *   initialDelayMs: 100,
- *   maxDelayMs: 5000,
- *   backoffMultiplier: 2,
- *   jitter: true
- * })
- *
- * let attempts = 0
- * while (attempts < 10) {
- *   try {
- *     await doOperation()
- *     break
- *   } catch (error) {
- *     attempts++
- *     if (!policy.shouldRetry(attempts)) {
- *       throw new Error('Max retries exceeded')
- *     }
- *     const delay = policy.getDelay(attempts)
- *     console.log(`Retry ${attempts} after ${delay}ms`)
- *     await sleep(delay)
- *   }
- * }
- * ```
- *
- * @class CDCRetryPolicy
- */
-export class CDCRetryPolicy {
-    /**
-     * Retry configuration.
-     * @private
-     */
-    config;
-    /**
-     * Creates a new retry policy.
-     *
-     * @param config - Retry policy configuration
-     */
-    constructor(config) {
-        this.config = config;
-    }
-    /**
-     * Determines whether another retry should be attempted.
-     *
-     * @param attemptCount - Number of attempts already made
-     * @returns true if more retries are allowed, false otherwise
-     *
-     * @example
-     * ```typescript
-     * if (policy.shouldRetry(3)) {
-     *   // Retry is allowed
-     * }
-     * ```
-     */
-    shouldRetry(attemptCount) {
-        return attemptCount < this.config.maxRetries;
-    }
-    /**
-     * Calculates the delay before the next retry.
-     *
-     * @description
-     * Computes delay using exponential backoff, capped at maxDelayMs.
-     * If jitter is enabled, applies a random factor between 0.5x and 1.5x.
-     *
-     * @param attemptCount - Number of attempts already made (1-indexed)
-     * @returns Delay in milliseconds before next retry
-     *
-     * @example
-     * ```typescript
-     * // With initialDelay=100, multiplier=2:
-     * // Attempt 1: 100ms * 2^0 = 100ms
-     * // Attempt 2: 100ms * 2^1 = 200ms
-     * // Attempt 3: 100ms * 2^2 = 400ms
-     * const delay = policy.getDelay(attemptCount)
-     * await sleep(delay)
-     * ```
-     */
-    getDelay(attemptCount) {
-        let delay = this.config.initialDelayMs * Math.pow(this.config.backoffMultiplier, attemptCount);
-        delay = Math.min(delay, this.config.maxDelayMs);
-        if (this.config.jitter) {
-            // Add random jitter between 0.5x and 1.5x
-            const jitterFactor = 0.5 + Math.random();
-            delay = Math.floor(delay * jitterFactor);
-        }
-        return delay;
-    }
-}
-// ============================================================================
-// CDC Event Capture
-// ============================================================================
-/**
- * Captures git operations and converts them to CDC events.
- *
- * @description
- * CDCEventCapture hooks into git operations and generates CDCEvents for each
- * operation. It maintains an internal buffer of events that can be flushed
- * manually or automatically when the buffer reaches a configured size.
- *
- * **Supported Operations:**
- * - Object creation/deletion (blobs, trees, commits, tags)
- * - Reference updates (branches, tags)
- * - Commit creation
- * - Pack reception
- * - Branch creation/deletion
- * - Tag creation
- * - Merge completion
- *
- * **Event Ordering:**
- * Events are assigned monotonically increasing sequence numbers within a
- * capture session. This ensures proper ordering for replay and analytics.
- *
- * @example
- * ```typescript
- * const capture = new CDCEventCapture({ maxBufferSize: 100 })
- *
- * // Add a listener for real-time processing
- * capture.addListener((event) => {
- *   console.log(`Event: ${event.type} - ${event.id}`)
- * })
- *
- * // Capture git operations
- * await capture.onCommitCreated('abc123...', 'tree456...', ['parent789...'])
- * await capture.onRefUpdate('refs/heads/main', 'old...', 'new...')
- *
- * // Get buffered events
- * console.log(`Buffer size: ${capture.getBufferSize()}`)
- *
- * // Flush buffer
- * const events = await capture.flush()
- * console.log(`Flushed ${events.length} events`)
- * ```
- *
- * @class CDCEventCapture
- */
-export class CDCEventCapture {
-    /**
-     * Buffer of captured events.
-     * @private
-     */
-    events = [];
-    /**
-     * Monotonically increasing sequence counter.
-     * @private
-     */
-    sequenceCounter = 0;
-    /**
-     * Registered event listeners.
-     * @private
-     */
-    listeners = [];
-    /**
-     * Maximum buffer size before auto-flush.
-     * @private
-     */
-    maxBufferSize;
-    /**
-     * Creates a new CDC event capture instance.
-     *
-     * @param options - Configuration options
-     */
-    constructor(options = {}) {
-        this.maxBufferSize = options.maxBufferSize ?? Infinity;
-    }
-    /**
-     * Generates a unique event ID.
-     * @private
-     */
-    generateEventId() {
-        return `evt-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    }
-    /**
-     * Emits an event to the buffer and notifies listeners.
-     * @private
-     */
-    async emitEvent(event) {
-        // Auto-flush if buffer is full
-        if (this.events.length >= this.maxBufferSize) {
-            await this.flush();
-        }
-        this.events.push(event);
-        // Notify all listeners
-        for (const listener of this.listeners) {
-            listener(event);
-        }
-    }
-    /**
-     * Returns the next sequence number.
-     * @private
-     */
-    nextSequence() {
-        return ++this.sequenceCounter;
-    }
-    /**
-     * Captures an object put (creation) operation.
-     *
-     * @description
-     * Called when a git object (blob, tree, commit, tag) is written to storage.
-     *
-     * @param sha - SHA-1 hash of the object
-     * @param type - Object type (blob, tree, commit, tag)
-     * @param data - Raw object data
-     *
-     * @example
-     * ```typescript
-     * await capture.onObjectPut('abc123...', 'blob', blobData)
-     * ```
-     */
-    async onObjectPut(sha, type, data) {
-        const event = {
-            id: this.generateEventId(),
-            type: 'OBJECT_CREATED',
-            source: 'push',
-            timestamp: Date.now(),
-            payload: {
-                operation: 'put',
-                sha,
-                data,
-                metadata: { type, size: data.length }
-            },
-            sequence: this.nextSequence(),
-            version: 1
-        };
-        await this.emitEvent(event);
-    }
-    /**
-     * Captures an object deletion operation.
-     *
-     * @description
-     * Called when a git object is deleted, typically during garbage collection.
-     *
-     * @param sha - SHA-1 hash of the deleted object
-     *
-     * @example
-     * ```typescript
-     * await capture.onObjectDelete('abc123...')
-     * ```
-     */
-    async onObjectDelete(sha) {
-        const event = {
-            id: this.generateEventId(),
-            type: 'OBJECT_DELETED',
-            source: 'gc',
-            timestamp: Date.now(),
-            payload: {
-                operation: 'delete',
-                sha
-            },
-            sequence: this.nextSequence(),
-            version: 1
-        };
-        await this.emitEvent(event);
-    }
-    /**
-     * Captures a reference update operation.
-     *
-     * @description
-     * Called when a git reference (branch, tag) is updated to point to a new commit.
-     *
-     * @param refName - Full reference name (e.g., 'refs/heads/main')
-     * @param oldSha - Previous SHA (all zeros for new refs)
-     * @param newSha - New SHA (all zeros for deleted refs)
-     *
-     * @example
-     * ```typescript
-     * await capture.onRefUpdate(
-     *   'refs/heads/main',
-     *   'oldcommit123...',
-     *   'newcommit456...'
-     * )
-     * ```
-     */
-    async onRefUpdate(refName, oldSha, newSha) {
-        const event = {
-            id: this.generateEventId(),
-            type: 'REF_UPDATED',
-            source: 'push',
-            timestamp: Date.now(),
-            payload: {
-                operation: 'ref-update',
-                refName,
-                oldSha,
-                newSha
-            },
-            sequence: this.nextSequence(),
-            version: 1
-        };
-        await this.emitEvent(event);
-    }
-    /**
-     * Captures a commit creation operation.
-     *
-     * @description
-     * Called when a new commit object is created.
-     *
-     * @param commitSha - SHA-1 hash of the commit
-     * @param treeSha - SHA-1 hash of the tree the commit points to
-     * @param parentShas - Array of parent commit SHAs
-     *
-     * @example
-     * ```typescript
-     * await capture.onCommitCreated(
-     *   'commitabc123...',
-     *   'treedef456...',
-     *   ['parent1...', 'parent2...']
-     * )
-     * ```
-     */
-    async onCommitCreated(commitSha, treeSha, parentShas) {
-        const event = {
-            id: this.generateEventId(),
-            type: 'COMMIT_CREATED',
-            source: 'push',
-            timestamp: Date.now(),
-            payload: {
-                operation: 'commit-create',
-                sha: commitSha,
-                treeSha,
-                parentShas
-            },
-            sequence: this.nextSequence(),
-            version: 1
-        };
-        await this.emitEvent(event);
-    }
-    /**
-     * Captures a pack reception operation.
-     *
-     * @description
-     * Called when a packfile is received during a push or fetch operation.
-     *
-     * @param packData - Raw packfile data
-     * @param objectCount - Number of objects in the pack
-     *
-     * @example
-     * ```typescript
-     * await capture.onPackReceived(packBuffer, 42)
-     * ```
-     */
-    async onPackReceived(packData, objectCount) {
-        const event = {
-            id: this.generateEventId(),
-            type: 'PACK_RECEIVED',
-            source: 'push',
-            timestamp: Date.now(),
-            payload: {
-                operation: 'pack-receive',
-                data: packData,
-                objectCount
-            },
-            sequence: this.nextSequence(),
-            version: 1
-        };
-        await this.emitEvent(event);
-    }
-    /**
-     * Captures a branch creation operation.
-     *
-     * @param branchName - Name of the branch (without refs/heads/ prefix)
-     * @param sha - SHA-1 hash the branch points to
-     *
-     * @example
-     * ```typescript
-     * await capture.onBranchCreated('feature-x', 'abc123...')
-     * ```
-     */
-    async onBranchCreated(branchName, sha) {
-        const event = {
-            id: this.generateEventId(),
-            type: 'BRANCH_CREATED',
-            source: 'push',
-            timestamp: Date.now(),
-            payload: {
-                operation: 'branch-create',
-                branchName,
-                sha
-            },
-            sequence: this.nextSequence(),
-            version: 1
-        };
-        await this.emitEvent(event);
-    }
-    /**
-     * Captures a branch deletion operation.
-     *
-     * @param branchName - Name of the deleted branch
-     *
-     * @example
-     * ```typescript
-     * await capture.onBranchDeleted('feature-x')
-     * ```
-     */
-    async onBranchDeleted(branchName) {
-        const event = {
-            id: this.generateEventId(),
-            type: 'BRANCH_DELETED',
-            source: 'push',
-            timestamp: Date.now(),
-            payload: {
-                operation: 'branch-delete',
-                branchName
-            },
-            sequence: this.nextSequence(),
-            version: 1
-        };
-        await this.emitEvent(event);
-    }
-    /**
-     * Captures a tag creation operation.
-     *
-     * @param tagName - Name of the tag
-     * @param sha - SHA-1 hash the tag points to
-     *
-     * @example
-     * ```typescript
-     * await capture.onTagCreated('v1.0.0', 'abc123...')
-     * ```
-     */
-    async onTagCreated(tagName, sha) {
-        const event = {
-            id: this.generateEventId(),
-            type: 'TAG_CREATED',
-            source: 'push',
-            timestamp: Date.now(),
-            payload: {
-                operation: 'tag-create',
-                tagName,
-                sha
-            },
-            sequence: this.nextSequence(),
-            version: 1
-        };
-        await this.emitEvent(event);
-    }
-    /**
-     * Captures a merge completion operation.
-     *
-     * @param mergeSha - SHA-1 hash of the merge commit
-     * @param baseSha - SHA-1 hash of the base commit
-     * @param headSha - SHA-1 hash of the head commit being merged
-     *
-     * @example
-     * ```typescript
-     * await capture.onMergeCompleted('merge123...', 'base456...', 'head789...')
-     * ```
-     */
-    async onMergeCompleted(mergeSha, baseSha, headSha) {
-        const event = {
-            id: this.generateEventId(),
-            type: 'MERGE_COMPLETED',
-            source: 'push',
-            timestamp: Date.now(),
-            payload: {
-                operation: 'merge-complete',
-                sha: mergeSha,
-                baseSha,
-                headSha
-            },
-            sequence: this.nextSequence(),
-            version: 1
-        };
-        await this.emitEvent(event);
-    }
-    /**
-     * Returns a copy of all buffered events.
-     *
-     * @returns Array of buffered events
-     */
-    getEvents() {
-        return [...this.events];
-    }
-    /**
-     * Returns the current buffer size.
-     *
-     * @returns Number of events in the buffer
-     */
-    getBufferSize() {
-        return this.events.length;
-    }
-    /**
-     * Flushes all buffered events.
-     *
-     * @description
-     * Returns and clears all events from the buffer. The returned events
-     * can be processed, serialized, or forwarded to downstream systems.
-     *
-     * @returns Array of flushed events
-     *
-     * @example
-     * ```typescript
-     * const events = await capture.flush()
-     * console.log(`Flushed ${events.length} events`)
-     * await sendToAnalytics(events)
-     * ```
-     */
-    async flush() {
-        const flushed = [...this.events];
-        this.events = [];
-        return flushed;
-    }
-    /**
-     * Adds an event listener.
-     *
-     * @description
-     * Listeners are called synchronously for each event as it is captured.
-     *
-     * @param listener - Callback function to invoke for each event
-     *
-     * @example
-     * ```typescript
-     * capture.addListener((event) => {
-     *   console.log(`New event: ${event.type}`)
-     * })
-     * ```
-     */
-    addListener(listener) {
-        this.listeners.push(listener);
-    }
-    /**
-     * Removes an event listener.
-     *
-     * @param listener - The listener to remove
-     */
-    removeListener(listener) {
-        const index = this.listeners.indexOf(listener);
-        if (index !== -1) {
-            this.listeners.splice(index, 1);
-        }
-    }
-}
-// ============================================================================
-// Parquet Schema
-// ============================================================================
-/**
- * Default field definitions for CDC event Parquet schema.
- * @internal
- */
-const CDC_EVENT_FIELDS = [
-    { name: 'event_id', type: 'STRING', nullable: false },
-    { name: 'event_type', type: 'STRING', nullable: false },
-    { name: 'source', type: 'STRING', nullable: false },
-    { name: 'timestamp', type: 'TIMESTAMP', nullable: false },
-    { name: 'sequence', type: 'INT64', nullable: false },
-    { name: 'version', type: 'INT64', nullable: false },
-    { name: 'payload_json', type: 'STRING', nullable: false },
-    { name: 'sha', type: 'STRING', nullable: true }
-];
-/**
- * Parquet schema definition for CDC events.
- *
- * @description
- * Defines the column structure for CDC event Parquet files. The default
- * schema includes standard CDC event fields and can be extended with
- * custom fields for domain-specific data.
- *
- * @example
- * ```typescript
- * // Create default schema
- * const schema = ParquetSchema.forCDCEvents()
- *
- * // Create schema with custom fields
- * const customSchema = ParquetSchema.forCDCEvents([
- *   { name: 'repository_id', type: 'STRING', nullable: false },
- *   { name: 'user_id', type: 'STRING', nullable: true }
- * ])
- * ```
- *
- * @class ParquetSchema
- */
-export class ParquetSchema {
-    fields;
-    /**
-     * Creates a new ParquetSchema.
-     *
-     * @param fields - Array of field definitions
-     */
-    constructor(fields) {
-        this.fields = fields;
-    }
-    /**
-     * Creates a schema for CDC events with optional custom fields.
-     *
-     * @description
-     * Returns a schema with the standard CDC event fields. Additional
-     * custom fields can be appended for domain-specific data.
-     *
-     * @param customFields - Optional additional fields to add
-     * @returns A new ParquetSchema instance
-     *
-     * @example
-     * ```typescript
-     * const schema = ParquetSchema.forCDCEvents()
-     * // Schema includes: event_id, event_type, source, timestamp,
-     * //                  sequence, version, payload_json, sha
-     * ```
-     */
-    static forCDCEvents(customFields) {
-        const fields = [...CDC_EVENT_FIELDS];
-        if (customFields) {
-            fields.push(...customFields);
-        }
-        return new ParquetSchema(fields);
-    }
-}
-/**
- * Transforms CDC events to Parquet format.
- *
- * @description
- * ParquetTransformer converts CDC events to Parquet-compatible rows and
- * serializes batches of events to Parquet file format. It handles:
- *
- * - Event to row conversion (flattening the event structure)
- * - JSON serialization of complex payloads
- * - Batch creation with schema and metadata
- * - Parquet file generation with compression
- *
- * @example
- * ```typescript
- * const transformer = new ParquetTransformer({ compression: 'snappy' })
- *
- * // Transform single event to row
- * const row = transformer.eventToRow(event)
- *
- * // Transform batch of events
- * const batch = transformer.eventsToBatch(events)
- *
- * // Generate Parquet file
- * const buffer = await transformer.toParquetBuffer(batch)
- * await r2.put('events.parquet', buffer)
- * ```
- *
- * @class ParquetTransformer
- */
-export class ParquetTransformer {
-    /**
-     * Compression algorithm to use.
-     * @private
-     */
-    compression;
-    /**
-     * Creates a new ParquetTransformer.
-     *
-     * @param options - Transformer configuration
-     */
-    constructor(options = {}) {
-        this.compression = options.compression ?? 'snappy';
-    }
-    /**
-     * Converts a CDC event to a Parquet row.
-     *
-     * @description
-     * Flattens the event structure and serializes the payload to JSON
-     * for storage in Parquet format.
-     *
-     * @param event - The CDC event to convert
-     * @returns A Parquet row representation
-     *
-     * @example
-     * ```typescript
-     * const row = transformer.eventToRow(event)
-     * console.log(row.event_id, row.event_type, row.sha)
-     * ```
-     */
-    eventToRow(event) {
-        // Create a serializable copy of the payload (Uint8Array not JSON-serializable)
-        const serializablePayload = {
-            ...event.payload,
-            data: event.payload.data ? Array.from(event.payload.data) : undefined
-        };
-        return {
-            event_id: event.id,
-            event_type: event.type,
-            source: event.source,
-            timestamp: event.timestamp,
-            sequence: event.sequence,
-            version: event.version,
-            payload_json: JSON.stringify(serializablePayload),
-            sha: event.payload.sha ?? null
-        };
-    }
-    /**
-     * Converts multiple CDC events to a Parquet batch.
-     *
-     * @description
-     * Transforms an array of events into a ParquetBatch structure
-     * ready for serialization to Parquet format.
-     *
-     * @param events - Array of CDC events to batch
-     * @returns A ParquetBatch ready for serialization
-     *
-     * @example
-     * ```typescript
-     * const batch = transformer.eventsToBatch(events)
-     * console.log(`Batch has ${batch.rowCount} rows`)
-     * ```
-     */
-    eventsToBatch(events) {
-        const rows = events.map(e => this.eventToRow(e));
-        return {
-            rows,
-            rowCount: rows.length,
-            createdAt: Date.now(),
-            schema: ParquetSchema.forCDCEvents(),
-            compression: this.compression
-        };
-    }
-    /**
-     * Serializes a ParquetBatch to a Parquet file buffer.
-     *
-     * @description
-     * Generates a Parquet-format file from the batch data. The output
-     * includes PAR1 magic bytes, compressed data, and footer metadata.
-     *
-     * @param batch - The ParquetBatch to serialize
-     * @returns Promise resolving to Parquet file as Uint8Array
-     *
-     * @example
-     * ```typescript
-     * const buffer = await transformer.toParquetBuffer(batch)
-     * await r2.put('events.parquet', buffer)
-     * ```
-     */
-    async toParquetBuffer(batch) {
-        // Build a simplified Parquet-like buffer
-        // Real implementation would use a proper Parquet library
-        const encoder = new TextEncoder();
-        // Magic bytes
-        const magic = encoder.encode('PAR1');
-        // Serialize batch data
-        const dataJson = JSON.stringify({
-            rows: batch.rows,
-            rowCount: batch.rowCount,
-            createdAt: batch.createdAt,
-            schema: batch.schema,
-            compression: batch.compression
-        });
-        let dataBytes = encoder.encode(dataJson);
-        // Apply compression
-        if (this.compression === 'gzip') {
-            dataBytes = await this.gzipCompress(dataBytes);
-        }
-        else if (this.compression === 'snappy') {
-            // Snappy simulation (use simple compression)
-            dataBytes = await this.simpleCompress(dataBytes);
-        }
-        // Build final buffer: PAR1 + data + length (4 bytes) + PAR1
-        const lengthBytes = new Uint8Array(4);
-        new DataView(lengthBytes.buffer).setUint32(0, dataBytes.length, true);
-        const totalSize = 4 + dataBytes.length + 4 + 4;
-        const result = new Uint8Array(totalSize);
-        let offset = 0;
-        result.set(magic, offset);
-        offset += 4;
-        result.set(dataBytes, offset);
-        offset += dataBytes.length;
-        result.set(lengthBytes, offset);
-        offset += 4;
-        result.set(magic, offset);
-        return result;
-    }
-    async gzipCompress(data) {
-        // Use CompressionStream if available (modern browsers/Node 18+)
-        if (typeof CompressionStream !== 'undefined') {
-            const stream = new CompressionStream('gzip');
-            const writer = stream.writable.getWriter();
-            writer.write(data);
-            writer.close();
-            const reader = stream.readable.getReader();
-            const chunks = [];
-            let done = false;
-            while (!done) {
-                const result = await reader.read();
-                done = result.done;
-                if (result.value) {
-                    chunks.push(result.value);
-                }
-            }
-            const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
-            const result = new Uint8Array(totalLength);
-            let offset = 0;
-            for (const chunk of chunks) {
-                result.set(chunk, offset);
-                offset += chunk.length;
-            }
-            return result;
-        }
-        // Fallback: return data as-is (no compression)
-        return data;
-    }
-    async simpleCompress(data) {
-        // For snappy, we just return data as-is (real snappy compression would require a library)
-        // This is a simplified implementation that avoids async stream issues with fake timers
-        return data;
-    }
-}
-/**
- * Batches CDC events for efficient processing.
- *
- * @description
- * CDCBatcher collects CDC events and groups them into batches based on
- * count or time thresholds. This enables efficient downstream processing
- * by reducing the number of I/O operations and enabling bulk operations.
- *
- * **Batching Strategies:**
- * - **Count-based**: Flush when batch reaches `batchSize` events
- * - **Time-based**: Flush after `flushIntervalMs` even if batch is not full
- *
- * **Features:**
- * - Async batch handlers for non-blocking processing
- * - Multiple handlers for parallel processing pipelines
- * - Graceful stop with pending event flush
- * - Batch metadata (sequences, timestamps) for tracking
- *
- * @example
- * ```typescript
- * const batcher = new CDCBatcher({
- *   batchSize: 100,
- *   flushIntervalMs: 5000
- * })
- *
- * // Register batch handler
- * batcher.onBatch(async (batch) => {
- *   console.log(`Processing ${batch.eventCount} events`)
- *   console.log(`Sequence range: ${batch.minSequence} - ${batch.maxSequence}`)
- *   await saveToStorage(batch.events)
- * })
- *
- * // Add events
- * await batcher.add(event1)
- * await batcher.add(event2)
- *
- * // Check pending events
- * console.log(`Pending: ${batcher.getPendingCount()}`)
- *
- * // Manual flush
- * const result = await batcher.flush()
- *
- * // Stop the batcher
- * await batcher.stop()
- * ```
- *
- * @class CDCBatcher
- */
-export class CDCBatcher {
-    /**
-     * Batch configuration.
-     * @private
-     */
-    config;
-    /**
-     * Buffer of pending events.
-     * @private
-     */
-    events = [];
-    /**
-     * Registered batch handlers.
-     * @private
-     */
-    batchHandlers = [];
-    /**
-     * Timer for time-based flushing.
-     * @private
-     */
-    flushTimer = null;
-    /**
-     * Whether the batcher has been stopped.
-     * @private
-     */
-    stopped = false;
-    /**
-     * Creates a new CDCBatcher.
-     *
-     * @param config - Batch configuration
-     */
-    constructor(config) {
-        this.config = config;
-        // Don't start timer in constructor - start when first event is added
-    }
-    ensureTimerRunning() {
-        if (this.stopped)
-            return;
-        if (this.flushTimer !== null)
-            return; // Already have a timer
-        this.flushTimer = setTimeout(() => {
-            this.flushTimer = null;
-            if (this.stopped)
-                return;
-            // Process pending events if any
-            if (this.events.length > 0) {
-                // Build batch result
-                const batchEvents = [...this.events];
-                this.events = [];
-                const sequences = batchEvents.map(e => e.sequence);
-                const timestamps = batchEvents.map(e => e.timestamp);
-                const result = {
-                    events: batchEvents,
-                    eventCount: batchEvents.length,
-                    success: true,
-                    minSequence: Math.min(...sequences),
-                    maxSequence: Math.max(...sequences),
-                    minTimestamp: Math.min(...timestamps),
-                    maxTimestamp: Math.max(...timestamps)
-                };
-                // Notify handlers and handle promises
-                const handlerPromises = [];
-                for (const handler of this.batchHandlers) {
-                    try {
-                        const maybePromise = handler(result);
-                        if (maybePromise && typeof maybePromise.then === 'function') {
-                            handlerPromises.push(maybePromise);
-                        }
-                    }
-                    catch {
-                        // Ignore handler errors in timer context
-                    }
-                }
-                // Execute all handlers and ignore the result
-                if (handlerPromises.length > 0) {
-                    void Promise.all(handlerPromises);
-                }
-            }
-            // DON'T reschedule here - timer will be scheduled on next add() call
-        }, this.config.flushIntervalMs);
-    }
-    clearFlushTimer() {
-        if (this.flushTimer !== null) {
-            clearTimeout(this.flushTimer);
-            this.flushTimer = null;
-        }
-    }
-    /**
-     * Adds an event to the batch.
-     *
-     * @description
-     * Adds the event to the pending batch. If the batch reaches the
-     * configured size, it is automatically flushed. The flush timer
-     * is started/restarted as needed.
-     *
-     * @param event - The CDC event to add
-     *
-     * @example
-     * ```typescript
-     * await batcher.add(event)
-     * ```
-     */
-    async add(event) {
-        this.events.push(event);
-        // Ensure flush timer is running when we have pending events
-        this.ensureTimerRunning();
-        if (this.events.length >= this.config.batchSize) {
-            this.clearFlushTimer();
-            await this.flushInternal();
-            // Timer will be re-started on next add() if needed
-        }
-    }
-    /**
-     * Internal flush implementation.
-     * @private
-     */
-    async flushInternal() {
-        if (this.events.length === 0) {
-            return { events: [], eventCount: 0, success: true };
-        }
-        const batchEvents = [...this.events];
-        this.events = [];
-        const sequences = batchEvents.map(e => e.sequence);
-        const timestamps = batchEvents.map(e => e.timestamp);
-        const result = {
-            events: batchEvents,
-            eventCount: batchEvents.length,
-            success: true,
-            minSequence: Math.min(...sequences),
-            maxSequence: Math.max(...sequences),
-            minTimestamp: Math.min(...timestamps),
-            maxTimestamp: Math.max(...timestamps)
-        };
-        // Notify handlers (await async handlers)
-        for (const handler of this.batchHandlers) {
-            await handler(result);
-        }
-        return result;
-    }
-    /**
-     * Manually flushes pending events.
-     *
-     * @description
-     * Forces an immediate flush of all pending events, regardless of
-     * batch size or timer. Clears the flush timer.
-     *
-     * @returns Promise resolving to the batch result
-     *
-     * @example
-     * ```typescript
-     * const result = await batcher.flush()
-     * console.log(`Flushed ${result.eventCount} events`)
-     * ```
-     */
-    async flush() {
-        this.clearFlushTimer();
-        const result = await this.flushInternal();
-        // Don't restart timer - it will be started on next add() if needed
-        return result;
-    }
-    /**
-     * Returns the number of pending events.
-     *
-     * @returns Number of events waiting to be flushed
-     */
-    getPendingCount() {
-        return this.events.length;
-    }
-    /**
-     * Registers a batch handler.
-     *
-     * @description
-     * Handlers are called when a batch is flushed (automatically or manually).
-     * Multiple handlers can be registered for parallel processing.
-     *
-     * @param handler - Callback function to invoke for each batch
-     *
-     * @example
-     * ```typescript
-     * batcher.onBatch(async (batch) => {
-     *   await saveToStorage(batch.events)
-     * })
-     * ```
-     */
-    onBatch(handler) {
-        this.batchHandlers.push(handler);
-    }
-    /**
-     * Stops the batcher.
-     *
-     * @description
-     * Stops the flush timer and prevents further processing.
-     * Does NOT automatically flush pending events - call flush() first
-     * if you need to process remaining events.
-     *
-     * @example
-     * ```typescript
-     * await batcher.flush()  // Process remaining events
-     * await batcher.stop()   // Stop the timer
-     * ```
-     */
-    async stop() {
-        this.stopped = true;
-        this.clearFlushTimer();
-    }
-}
-/**
- * Main CDC Pipeline for processing git operation events.
- *
- * @description
- * CDCPipeline orchestrates the complete change data capture flow from
- * event ingestion to Parquet output. It integrates batching, transformation,
- * retry handling, and dead letter queue management.
- *
- * **Pipeline Flow:**
- * 1. Events are submitted via `process()` or `processMany()`
- * 2. Events are validated and added to the batcher
- * 3. When a batch is ready, it's transformed to Parquet format
- * 4. On success, output handlers are notified
- * 5. On failure, retries are attempted with exponential backoff
- * 6. After max retries, events go to dead letter queue
- *
- * **Features:**
- * - Configurable batch size and flush interval
- * - Automatic retry with exponential backoff
- * - Dead letter queue for failed events
- * - Real-time metrics for monitoring
- * - Graceful shutdown with pending event flush
- *
- * @example
- * ```typescript
- * const pipeline = new CDCPipeline({
- *   batchSize: 100,
- *   flushIntervalMs: 5000,
- *   maxRetries: 3,
- *   parquetCompression: 'snappy',
- *   outputPath: '/analytics',
- *   schemaVersion: 1
- * })
- *
- * // Register handlers
- * pipeline.onOutput(async (output) => {
- *   await r2.put(`cdc/${output.batchId}.parquet`, output.parquetBuffer)
- * })
- *
- * pipeline.onDeadLetter((events, error) => {
- *   console.error(`Failed ${events.length} events:`, error)
- * })
- *
- * // Start the pipeline
- * await pipeline.start()
- *
- * // Process events
- * await pipeline.process(event)
- *
- * // Check metrics
- * const metrics = pipeline.getMetrics()
- *
- * // Stop gracefully
- * const result = await pipeline.stop()
- * console.log(`Flushed ${result.flushedCount} events on shutdown`)
- * ```
- *
- * @class CDCPipeline
- */
-export class CDCPipeline {
-    /**
-     * Pipeline configuration.
-     * @private
-     */
-    config;
-    /**
-     * Current pipeline state.
-     * @private
-     */
-    state = 'stopped';
-    /**
-     * Event batcher instance.
-     * @private
-     */
-    batcher = null;
-    /**
-     * Parquet transformer instance.
-     * @private
-     */
-    transformer;
-    /**
-     * Registered output handlers.
-     * @private
-     */
-    outputHandlers = [];
-    /**
-     * Registered dead letter handlers.
-     * @private
-     */
-    deadLetterHandlers = [];
-    /**
-     * Pipeline metrics.
-     * @private
-     */
-    metrics = {
-        eventsProcessed: 0,
-        batchesGenerated: 0,
-        bytesWritten: 0,
-        errors: 0,
-        avgProcessingLatencyMs: 0
-    };
-    /**
-     * Processing latency samples.
-     * @private
-     */
-    processingLatencies = [];
-    /**
-     * Retry policy instance.
-     * @private
-     */
-    retryPolicy;
-    /**
-     * Creates a new CDCPipeline.
-     *
-     * @param config - Pipeline configuration
-     */
-    constructor(config) {
-        this.config = config;
-        this.transformer = new ParquetTransformer({
-            compression: config.parquetCompression
-        });
-        this.retryPolicy = new CDCRetryPolicy({
-            maxRetries: config.maxRetries,
-            initialDelayMs: 100,
-            maxDelayMs: 5000,
-            backoffMultiplier: 2
-        });
-    }
-    /**
-     * Returns the current pipeline state.
-     *
-     * @returns Current state ('stopped', 'running', or 'paused')
-     */
-    getState() {
-        return this.state;
-    }
-    /**
-     * Starts the pipeline.
-     *
-     * @description
-     * Initializes the batcher and begins accepting events. If already
-     * running, this method is a no-op.
-     *
-     * @example
-     * ```typescript
-     * await pipeline.start()
-     * console.log(pipeline.getState())  // 'running'
-     * ```
-     */
-    async start() {
-        if (this.state === 'running')
-            return;
-        this.batcher = new CDCBatcher({
-            batchSize: this.config.batchSize,
-            flushIntervalMs: this.config.flushIntervalMs
-        });
-        this.batcher.onBatch(async (batch) => {
-            await this.handleBatch(batch);
-        });
-        this.state = 'running';
-    }
-    /**
-     * Stops the pipeline.
-     *
-     * @description
-     * Flushes any pending events, stops the batcher, and sets state to stopped.
-     * Returns information about events flushed during shutdown.
-     *
-     * @returns Promise resolving to stop result with flushed event count
-     *
-     * @example
-     * ```typescript
-     * const result = await pipeline.stop()
-     * console.log(`Flushed ${result.flushedCount} events on shutdown`)
-     * ```
-     */
-    async stop() {
-        if (this.state === 'stopped') {
-            return { flushedCount: 0 };
-        }
-        let flushedCount = 0;
-        if (this.batcher) {
-            const result = await this.batcher.flush();
-            flushedCount = result.eventCount;
-            await this.batcher.stop();
-            this.batcher = null;
-        }
-        this.state = 'stopped';
-        return { flushedCount };
-    }
-    /**
-     * Processes a single event.
-     *
-     * @description
-     * Validates the event and adds it to the batcher for processing.
-     * Updates metrics including latency tracking.
-     *
-     * @param event - The CDC event to process
-     * @returns Promise resolving to process result
-     *
-     * @throws {CDCError} PROCESSING_ERROR - If pipeline is not running
-     * @throws {CDCError} VALIDATION_ERROR - If event fails validation
-     *
-     * @example
-     * ```typescript
-     * const result = await pipeline.process(event)
-     * if (result.success) {
-     *   console.log(`Processed event: ${result.eventId}`)
-     * }
-     * ```
-     */
-    async process(event) {
-        if (this.state !== 'running') {
-            throw new CDCError('PROCESSING_ERROR', 'Pipeline is not running');
-        }
-        // Validate event
-        validateCDCEvent(event);
-        const startTime = Date.now();
-        await this.batcher.add(event);
-        this.metrics.eventsProcessed++;
-        const latency = Date.now() - startTime;
-        this.processingLatencies.push(latency);
-        this.updateAvgLatency();
-        return { success: true, eventId: event.id };
-    }
-    /**
-     * Processes multiple events.
-     *
-     * @description
-     * Convenience method to process an array of events sequentially.
-     *
-     * @param events - Array of CDC events to process
-     * @returns Promise resolving to array of process results
-     *
-     * @example
-     * ```typescript
-     * const results = await pipeline.processMany(events)
-     * const successCount = results.filter(r => r.success).length
-     * console.log(`Processed ${successCount}/${events.length} events`)
-     * ```
-     */
-    async processMany(events) {
-        const results = [];
-        for (const event of events) {
-            const result = await this.process(event);
-            results.push(result);
-        }
-        return results;
-    }
-    /**
-     * Manually flushes pending events.
-     *
-     * @description
-     * Forces an immediate flush of the batcher and processes the
-     * resulting batch through the pipeline.
-     *
-     * @example
-     * ```typescript
-     * await pipeline.flush()
-     * console.log('All pending events flushed')
-     * ```
-     */
-    async flush() {
-        if (this.batcher) {
-            const result = await this.batcher.flush();
-            if (result.eventCount > 0) {
-                await this.handleBatch(result);
-            }
-        }
-    }
-    /**
-     * Handles a batch of events with retry logic.
-     * @private
-     */
-    async handleBatch(batch) {
-        let attempts = 0;
-        let lastError = null;
-        while (attempts <= this.config.maxRetries) {
-            try {
-                const parquetBatch = this.transformer.eventsToBatch(batch.events);
-                const parquetBuffer = await this.transformer.toParquetBuffer(parquetBatch);
-                const output = {
-                    parquetBuffer,
-                    events: batch.events,
-                    batchId: `batch-${Date.now()}-${Math.random().toString(36).slice(2)}`
-                };
-                // Notify output handlers
-                for (const handler of this.outputHandlers) {
-                    handler(output);
-                }
-                this.metrics.batchesGenerated++;
-                this.metrics.bytesWritten += parquetBuffer.length;
-                return; // Success
-            }
-            catch (error) {
-                lastError = error;
-                attempts++;
-                this.metrics.errors++;
-                if (this.retryPolicy.shouldRetry(attempts)) {
-                    const delay = this.retryPolicy.getDelay(attempts);
-                    await this.sleep(delay);
-                }
-            }
-        }
-        // All retries exhausted - send to dead letter queue
-        if (lastError) {
-            for (const handler of this.deadLetterHandlers) {
-                handler(batch.events, lastError);
-            }
-        }
-    }
-    /**
-     * Sleeps for the specified duration.
-     * @private
-     */
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Updates the average latency metric.
-     * @private
-     */
-    updateAvgLatency() {
-        if (this.processingLatencies.length === 0)
-            return;
-        // Keep only last 1000 measurements
-        if (this.processingLatencies.length > 1000) {
-            this.processingLatencies = this.processingLatencies.slice(-1000);
-        }
-        const sum = this.processingLatencies.reduce((a, b) => a + b, 0);
-        this.metrics.avgProcessingLatencyMs = sum / this.processingLatencies.length;
-    }
-    /**
-     * Returns current pipeline metrics.
-     *
-     * @description
-     * Returns a copy of the current metrics. Metrics are cumulative
-     * since pipeline creation.
-     *
-     * @returns Copy of current pipeline metrics
-     *
-     * @example
-     * ```typescript
-     * const metrics = pipeline.getMetrics()
-     * console.log(`Processed: ${metrics.eventsProcessed}`)
-     * console.log(`Batches: ${metrics.batchesGenerated}`)
-     * console.log(`Errors: ${metrics.errors}`)
-     * console.log(`Avg latency: ${metrics.avgProcessingLatencyMs}ms`)
-     * ```
-     */
-    getMetrics() {
-        return { ...this.metrics };
-    }
-    /**
-     * Registers an output handler.
-     *
-     * @description
-     * Output handlers are called when a batch is successfully processed
-     * and converted to Parquet format. Multiple handlers can be registered.
-     *
-     * @param handler - Callback to invoke for each successful batch
-     *
-     * @example
-     * ```typescript
-     * pipeline.onOutput(async (output) => {
-     *   await r2.put(`cdc/${output.batchId}.parquet`, output.parquetBuffer)
-     *   console.log(`Wrote ${output.events.length} events`)
-     * })
-     * ```
-     */
-    onOutput(handler) {
-        this.outputHandlers.push(handler);
-    }
-    /**
-     * Registers a dead letter handler.
-     *
-     * @description
-     * Dead letter handlers are called when a batch fails after all
-     * retry attempts are exhausted. Use this for alerting, logging,
-     * or storing failed events for later reprocessing.
-     *
-     * @param handler - Callback to invoke for failed events
-     *
-     * @example
-     * ```typescript
-     * pipeline.onDeadLetter((events, error) => {
-     *   console.error(`Failed to process ${events.length} events:`, error)
-     *   // Store in dead letter queue for later retry
-     *   await dlq.put(events)
-     * })
-     * ```
-     */
-    onDeadLetter(handler) {
-        this.deadLetterHandlers.push(handler);
-    }
-}
-// ============================================================================
-// Utility Functions
-// ============================================================================
-/**
- * Valid CDC event types for validation.
- * @internal
- */
-const VALID_EVENT_TYPES = [
-    'OBJECT_CREATED',
-    'OBJECT_DELETED',
-    'REF_UPDATED',
-    'PACK_RECEIVED',
-    'COMMIT_CREATED',
-    'TREE_MODIFIED',
-    'BRANCH_CREATED',
-    'BRANCH_DELETED',
-    'TAG_CREATED',
-    'MERGE_COMPLETED'
-];
-/**
- * Creates a new CDC event.
- *
- * @description
- * Factory function to create a properly structured CDC event with
- * automatically generated ID and timestamp.
- *
- * @param type - The event type
- * @param source - The event source
- * @param payload - Event payload data
- * @param options - Optional configuration
- * @param options.sequence - Custom sequence number (default: 0)
- * @returns A new CDCEvent
- *
- * @example
- * ```typescript
- * const event = createCDCEvent('COMMIT_CREATED', 'push', {
- *   operation: 'commit-create',
- *   sha: 'abc123...',
- *   treeSha: 'def456...',
- *   parentShas: ['parent1...']
- * })
- *
- * // With sequence number
- * const sequencedEvent = createCDCEvent('REF_UPDATED', 'push', {
- *   operation: 'ref-update',
- *   refName: 'refs/heads/main',
- *   oldSha: 'old...',
- *   newSha: 'new...'
- * }, { sequence: 42 })
- * ```
- */
-export function createCDCEvent(type, source, payload, options) {
-    return {
-        id: `evt-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-        type,
-        source,
-        timestamp: Date.now(),
-        payload,
-        sequence: options?.sequence ?? 0,
-        version: 1
-    };
-}
-/**
- * Serializes a CDC event to bytes.
- *
- * @description
- * Converts a CDCEvent to a JSON-encoded Uint8Array for storage or
- * transmission. Handles Uint8Array payload data by converting to arrays.
- *
- * @param event - The CDC event to serialize
- * @returns The serialized event as a Uint8Array
- *
- * @example
- * ```typescript
- * const bytes = serializeEvent(event)
- * await r2.put(`events/${event.id}`, bytes)
- * ```
- *
- * @see {@link deserializeEvent} - Reverse operation
- */
-export function serializeEvent(event) {
-    // Create a serializable copy (Uint8Array is not JSON-serializable)
-    const serializable = {
-        ...event,
-        payload: {
-            ...event.payload,
-            data: event.payload.data ? Array.from(event.payload.data) : undefined
-        }
-    };
-    const json = JSON.stringify(serializable);
-    return new TextEncoder().encode(json);
-}
-/**
- * Deserializes bytes to a CDC event.
- *
- * @description
- * Reconstructs a CDCEvent from JSON-encoded bytes. Handles Uint8Array
- * restoration for payload data that was converted to arrays during
- * serialization.
- *
- * @param bytes - The serialized event bytes
- * @returns The deserialized CDCEvent
- *
- * @example
- * ```typescript
- * const bytes = await r2.get(`events/${eventId}`)
- * const event = deserializeEvent(bytes)
- * console.log(`Event type: ${event.type}`)
- * ```
- *
- * @see {@link serializeEvent} - Reverse operation
- */
-export function deserializeEvent(bytes) {
-    const json = new TextDecoder().decode(bytes);
-    const parsed = JSON.parse(json);
-    // Restore Uint8Array if data was serialized
-    if (parsed.payload?.data && Array.isArray(parsed.payload.data)) {
-        parsed.payload.data = new Uint8Array(parsed.payload.data);
-    }
-    return parsed;
-}
-/**
- * Validates a CDC event.
- *
- * @description
- * Checks that an event has all required fields and valid values.
- * Throws a CDCError if validation fails.
- *
- * **Validation Rules:**
- * - Event must not be null/undefined
- * - Event ID must be a non-empty string
- * - Event type must be a valid CDCEventType
- * - Timestamp must be a non-negative number
- * - Sequence must be a non-negative number
- *
- * @param event - The CDC event to validate
- * @returns The validated event (for chaining)
- *
- * @throws {CDCError} VALIDATION_ERROR - If validation fails
- *
- * @example
- * ```typescript
- * try {
- *   validateCDCEvent(event)
- *   // Event is valid
- * } catch (error) {
- *   if (error instanceof CDCError) {
- *     console.log(`Invalid: ${error.message}`)
- *   }
- * }
- * ```
- */
-export function validateCDCEvent(event) {
-    if (!event) {
-        throw new CDCError('VALIDATION_ERROR', 'Event is null or undefined');
-    }
-    if (!event.id || typeof event.id !== 'string' || event.id.length === 0) {
-        throw new CDCError('VALIDATION_ERROR', 'Event id is missing or invalid');
-    }
-    if (!VALID_EVENT_TYPES.includes(event.type)) {
-        throw new CDCError('VALIDATION_ERROR', `Invalid event type: ${event.type}`);
-    }
-    if (typeof event.timestamp !== 'number' || event.timestamp < 0) {
-        throw new CDCError('VALIDATION_ERROR', 'Invalid timestamp');
-    }
-    if (typeof event.sequence !== 'number' || event.sequence < 0) {
-        throw new CDCError('VALIDATION_ERROR', 'Invalid sequence number');
-    }
-    return event;
-}
-// ============================================================================
-// Pipeline Operations
-// ============================================================================
-/**
- * Registry of active pipelines by ID.
- * @internal
- */
-const activePipelines = new Map();
-/**
- * Starts a new pipeline with the given configuration.
- *
- * @description
- * Creates and starts a new CDCPipeline, registering it by ID for
- * later access. If a pipeline with the same ID already exists,
- * it will be replaced (the old pipeline is not automatically stopped).
- *
- * @param id - Unique identifier for the pipeline
- * @param config - Pipeline configuration
- * @returns The started pipeline instance
- *
- * @example
- * ```typescript
- * const pipeline = startPipeline('main', {
- *   batchSize: 100,
- *   flushIntervalMs: 5000,
- *   maxRetries: 3,
- *   parquetCompression: 'snappy',
- *   outputPath: '/analytics',
- *   schemaVersion: 1
- * })
- *
- * // Register handlers
- * pipeline.onOutput((output) => console.log(`Batch: ${output.batchId}`))
- * ```
- */
-export function startPipeline(id, config) {
-    const pipeline = new CDCPipeline(config);
-    pipeline.start();
-    activePipelines.set(id, pipeline);
-    return pipeline;
-}
-/**
- * Stops a pipeline by ID.
- *
- * @description
- * Stops the pipeline identified by the given ID, flushing any pending
- * events and removing it from the registry.
- *
- * @param id - Pipeline identifier
- * @returns Promise resolving to stop result (0 if pipeline not found)
- *
- * @example
- * ```typescript
- * const result = await stopPipeline('main')
- * console.log(`Flushed ${result.flushedCount} events on shutdown`)
- * ```
- */
-export async function stopPipeline(id) {
-    const pipeline = activePipelines.get(id);
-    if (!pipeline) {
-        return { flushedCount: 0 };
-    }
-    const result = await pipeline.stop();
-    activePipelines.delete(id);
-    return result;
-}
-/**
- * Flushes a pipeline by ID.
- *
- * @description
- * Forces an immediate flush of all pending events in the pipeline.
- * No-op if pipeline not found.
- *
- * @param id - Pipeline identifier
- *
- * @example
- * ```typescript
- * await flushPipeline('main')
- * console.log('All pending events flushed')
- * ```
- */
-export async function flushPipeline(id) {
-    const pipeline = activePipelines.get(id);
-    if (pipeline) {
-        await pipeline.flush();
-    }
-}
-/**
- * Gets metrics for a pipeline by ID.
- *
- * @description
- * Returns a copy of the current metrics for the specified pipeline.
- * Returns null if the pipeline is not found.
- *
- * @param id - Pipeline identifier
- * @returns Pipeline metrics or null if not found
- *
- * @example
- * ```typescript
- * const metrics = getPipelineMetrics('main')
- * if (metrics) {
- *   console.log(`Events processed: ${metrics.eventsProcessed}`)
- *   console.log(`Errors: ${metrics.errors}`)
- * }
- * ```
- */
-export function getPipelineMetrics(id) {
-    const pipeline = activePipelines.get(id);
-    if (!pipeline) {
-        return null;
-    }
-    return pipeline.getMetrics();
-}
-//# sourceMappingURL=cdc-pipeline.js.map