qnce-engine 0.1.0 → 1.2.1

package/dist/examples/src/performance/PerfReporter.js

@@ -0,0 +1,280 @@
+"use strict";
+// S2-T4: Profiler Event Instrumentation
+// PerfReporter for batched performance event collection and reporting
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.perf = exports.PerfReporter = void 0;
+exports.getPerfReporter = getPerfReporter;
+exports.shutdownPerfReporter = shutdownPerfReporter;
+/**
+ * PerfReporter - Batched performance event collection and analysis
+ * Designed to work off main thread for minimal performance impact
+ */
+class PerfReporter {
+    events = [];
+    config;
+    flushTimer = null;
+    startTime;
+    activeSpans = new Map();
+    constructor(config = {}) {
+        this.config = {
+            batchSize: config.batchSize || 100,
+            flushInterval: config.flushInterval || 5000, // 5 seconds
+            enableBackgroundFlush: config.enableBackgroundFlush !== false,
+            maxEventHistory: config.maxEventHistory || 1000,
+            enableConsoleOutput: config.enableConsoleOutput || false
+        };
+        this.startTime = performance.now();
+        if (this.config.enableBackgroundFlush) {
+            this.startFlushTimer();
+        }
+    }
+    /**
+     * Record a performance event
+     */
+    record(type, metadata = {}, category = 'engine') {
+        const event = {
+            id: this.generateEventId(),
+            type,
+            timestamp: performance.now(),
+            metadata,
+            category
+        };
+        this.events.push(event);
+        if (this.config.enableConsoleOutput) {
+            console.log(`[PERF] ${type}:`, metadata);
+        }
+        // Auto-flush if batch size reached
+        if (this.events.length >= this.config.batchSize) {
+            this.flush();
+        }
+        return event.id;
+    }
+    /**
+     * Start a performance span (for measuring duration)
+     */
+    startSpan(type, metadata = {}, category = 'engine') {
+        const spanId = this.generateEventId();
+        const event = {
+            id: spanId,
+            type,
+            timestamp: performance.now(),
+            metadata: { ...metadata, spanStart: true },
+            category
+        };
+        this.activeSpans.set(spanId, event);
+        return spanId;
+    }
+    /**
+     * End a performance span and record the complete event
+     */
+    endSpan(spanId, additionalMetadata = {}) {
+        const startEvent = this.activeSpans.get(spanId);
+        if (!startEvent) {
+            console.warn(`[PERF] Span ${spanId} not found`);
+            return;
+        }
+        const endTime = performance.now();
+        const duration = endTime - startEvent.timestamp;
+        const completeEvent = {
+            ...startEvent,
+            duration,
+            metadata: {
+                ...startEvent.metadata,
+                ...additionalMetadata,
+                spanEnd: true
+            }
+        };
+        this.events.push(completeEvent);
+        this.activeSpans.delete(spanId);
+        if (this.config.enableConsoleOutput) {
+            console.log(`[PERF] ${startEvent.type} completed in ${duration.toFixed(2)}ms`);
+        }
+        // Auto-flush if batch size reached
+        if (this.events.length >= this.config.batchSize) {
+            this.flush();
+        }
+    }
+    /**
+     * Record flow start event (S2-T4 requirement)
+     */
+    recordFlowStart(nodeId, metadata = {}) {
+        return this.startSpan('flow-start', { nodeId, ...metadata }, 'engine');
+    }
+    /**
+     * Record flow completion event (S2-T4 requirement)
+     */
+    recordFlowComplete(spanId, nextNodeId, metadata = {}) {
+        this.endSpan(spanId, { nextNodeId, ...metadata });
+    }
+    /**
+     * Record cache hit event (S2-T4 requirement)
+     */
+    recordCacheHit(cacheKey, metadata = {}) {
+        return this.record('cache-hit', { cacheKey, ...metadata }, 'cache');
+    }
+    /**
+     * Record cache miss event (S2-T4 requirement)
+     */
+    recordCacheMiss(cacheKey, metadata = {}) {
+        return this.record('cache-miss', { cacheKey, ...metadata }, 'cache');
+    }
+    /**
+     * Record hot-reload start event (S2-T4 requirement)
+     */
+    recordHotReloadStart(deltaSize, metadata = {}) {
+        return this.startSpan('hot-reload-start', { deltaSize, ...metadata }, 'hot-reload');
+    }
+    /**
+     * Record hot-reload completion event (S2-T4 requirement)
+     */
+    recordHotReloadEnd(spanId, success, metadata = {}) {
+        this.endSpan(spanId, { success, ...metadata });
+    }
+    /**
+     * Generate performance summary for CLI dashboard
+     */
+    summary() {
+        const now = performance.now();
+        const eventsByType = {};
+        const durationsByType = {};
+        let cacheHits = 0;
+        let cacheMisses = 0;
+        let hotReloads = [];
+        // Analyze events
+        for (const event of this.events) {
+            // Count events by type
+            eventsByType[event.type] = (eventsByType[event.type] || 0) + 1;
+            // Collect durations
+            if (event.duration !== undefined) {
+                if (!durationsByType[event.type]) {
+                    durationsByType[event.type] = [];
+                }
+                durationsByType[event.type].push(event.duration);
+            }
+            // Cache metrics
+            if (event.type === 'cache-hit')
+                cacheHits++;
+            if (event.type === 'cache-miss')
+                cacheMisses++;
+            // Hot-reload metrics
+            if (event.type === 'hot-reload-start' && event.duration !== undefined) {
+                hotReloads.push(event.duration);
+            }
+        }
+        // Calculate averages, mins, maxs
+        const avgDurations = {};
+        const maxDurations = {};
+        const minDurations = {};
+        for (const [type, durations] of Object.entries(durationsByType)) {
+            if (durations.length > 0) {
+                avgDurations[type] = durations.reduce((sum, d) => sum + d, 0) / durations.length;
+                maxDurations[type] = Math.max(...durations);
+                minDurations[type] = Math.min(...durations);
+            }
+        }
+        // Cache hit rate
+        const totalCacheEvents = cacheHits + cacheMisses;
+        const cacheHitRate = totalCacheEvents > 0 ? (cacheHits / totalCacheEvents) * 100 : 0;
+        // Hot-reload performance
+        const hotReloadPerformance = {
+            avgTime: hotReloads.length > 0 ? hotReloads.reduce((sum, d) => sum + d, 0) / hotReloads.length : 0,
+            maxTime: hotReloads.length > 0 ? Math.max(...hotReloads) : 0,
+            totalReloads: hotReloads.length
+        };
+        return {
+            totalEvents: this.events.length,
+            eventsByType,
+            avgDurations,
+            maxDurations,
+            minDurations,
+            cacheHitRate,
+            hotReloadPerformance,
+            timeRange: {
+                start: this.startTime,
+                end: now,
+                duration: now - this.startTime
+            }
+        };
+    }
+    /**
+     * Get raw events for detailed analysis
+     */
+    getEvents() {
+        return [...this.events];
+    }
+    /**
+     * Clear event history
+     */
+    clear() {
+        this.events.length = 0;
+        this.activeSpans.clear();
+        this.startTime = performance.now();
+    }
+    /**
+     * Flush events to background processing
+     */
+    flush() {
+        if (this.events.length === 0)
+            return;
+        // TODO: Body - integrate with ThreadPool for background processing
+        // For now, just maintain event history with size limit
+        if (this.events.length > this.config.maxEventHistory) {
+            const excess = this.events.length - this.config.maxEventHistory;
+            this.events.splice(0, excess);
+        }
+        if (this.config.enableConsoleOutput) {
+            console.log(`[PERF] Flushed ${this.events.length} events`);
+        }
+    }
+    /**
+     * Start automatic flush timer
+     */
+    startFlushTimer() {
+        this.flushTimer = setInterval(() => {
+            this.flush();
+        }, this.config.flushInterval);
+    }
+    /**
+     * Stop automatic flush timer
+     */
+    stopFlushTimer() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+    /**
+     * Generate unique event ID
+     */
+    generateEventId() {
+        return `perf-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+}
+exports.PerfReporter = PerfReporter;
+// Singleton instance for global access
+let globalPerfReporter = null;
+function getPerfReporter(config) {
+    if (!globalPerfReporter) {
+        globalPerfReporter = new PerfReporter(config);
+    }
+    return globalPerfReporter;
+}
+function shutdownPerfReporter() {
+    if (globalPerfReporter) {
+        globalPerfReporter.stopFlushTimer();
+        globalPerfReporter.flush();
+        globalPerfReporter = null;
+    }
+}
+// Convenience functions for common operations
+exports.perf = {
+    flowStart: (nodeId, metadata) => getPerfReporter().recordFlowStart(nodeId, metadata),
+    flowComplete: (spanId, nextNodeId, metadata) => getPerfReporter().recordFlowComplete(spanId, nextNodeId, metadata),
+    cacheHit: (cacheKey, metadata) => getPerfReporter().recordCacheHit(cacheKey, metadata),
+    cacheMiss: (cacheKey, metadata) => getPerfReporter().recordCacheMiss(cacheKey, metadata),
+    hotReloadStart: (deltaSize, metadata) => getPerfReporter().recordHotReloadStart(deltaSize, metadata),
+    hotReloadEnd: (spanId, success, metadata) => getPerfReporter().recordHotReloadEnd(spanId, success, metadata),
+    record: (type, metadata, category) => getPerfReporter().record(type, metadata, category),
+    summary: () => getPerfReporter().summary(),
+    clear: () => getPerfReporter().clear()
+};

package/dist/examples/src/performance/ThreadPool.js

@@ -0,0 +1,347 @@
+"use strict";
+// S2-T2: Multithreaded Job Scheduler Integration
+// QnceThreadPool for cache loads and telemetry writes off main thread
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QnceThreadPool = void 0;
+exports.getThreadPool = getThreadPool;
+exports.shutdownThreadPool = shutdownThreadPool;
+/**
+ * QnceThreadPool - Background job processing for QNCE engine
+ * Handles cache operations, telemetry, and other non-blocking tasks
+ */
+class QnceThreadPool {
+    workers = [];
+    jobQueue = [];
+    activeJobs = new Map();
+    config;
+    stats;
+    isShuttingDown = false;
+    constructor(config = {}) {
+        this.config = {
+            maxWorkers: config.maxWorkers || Math.max(1, Math.floor(navigator?.hardwareConcurrency || 4) / 2),
+            queueLimit: config.queueLimit || 100,
+            idleTimeout: config.idleTimeout || 30000,
+            enableProfiling: config.enableProfiling || false
+        };
+        this.stats = {
+            activeWorkers: 0,
+            queuedJobs: 0,
+            completedJobs: 0,
+            failedJobs: 0,
+            avgExecutionTime: 0,
+            workerUtilization: 0
+        };
+        this.initializeWorkers();
+    }
+    /**
+     * Submit job for background processing
+     */
+    async submitJob(type, payload, priority = 'normal') {
+        return new Promise((resolve, reject) => {
+            if (this.isShuttingDown) {
+                reject(new Error('ThreadPool is shutting down'));
+                return;
+            }
+            if (this.jobQueue.length >= this.config.queueLimit) {
+                reject(new Error('Job queue limit exceeded'));
+                return;
+            }
+            const job = {
+                id: `job-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                type,
+                priority,
+                payload,
+                timestamp: performance.now(),
+                resolve: resolve,
+                reject
+            };
+            // Insert based on priority (high -> normal -> low)
+            const insertIndex = this.findInsertionIndex(priority);
+            this.jobQueue.splice(insertIndex, 0, job);
+            this.stats.queuedJobs = this.jobQueue.length;
+            this.processQueue();
+        });
+    }
+    /**
+     * Cache load operation (S2-T2 primary use case)
+     */
+    async loadFromCache(cacheKey, loader) {
+        return this.submitJob('cache-load', { cacheKey, loader: loader.toString() }, 'normal');
+    }
+    /**
+     * Telemetry write operation (S2-T2 primary use case)
+     */
+    async writeTelemetry(eventData) {
+        return this.submitJob('telemetry-write', eventData, 'low');
+    }
+    /**
+     * Hot-reload preparation (integration with S2-T3)
+     */
+    async prepareHotReload(deltaData) {
+        return this.submitJob('hot-reload-prep', deltaData, 'high');
+    }
+    /**
+     * Get current thread pool statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Graceful shutdown of thread pool
+     */
+    async shutdown(timeoutMs = 5000) {
+        this.isShuttingDown = true;
+        const startTime = Date.now();
+        // Wait for active jobs to complete or timeout
+        while (this.activeJobs.size > 0 && (Date.now() - startTime) < timeoutMs) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        // Terminate all workers
+        for (const worker of this.workers) {
+            worker.terminate();
+        }
+        this.workers.length = 0;
+        this.stats.activeWorkers = 0;
+    }
+    /**
+     * Initialize worker threads based on environment
+     */
+    initializeWorkers() {
+        // Browser environment: Use Web Workers
+        if (typeof Worker !== 'undefined' && typeof window !== 'undefined') {
+            this.initializeWebWorkers();
+        }
+        // Node.js environment: Use worker_threads
+        else if (typeof require !== 'undefined') {
+            this.initializeNodeWorkers();
+        }
+        // Fallback: Simulate workers with setTimeout (for testing)
+        else {
+            this.initializeFallbackWorkers();
+        }
+    }
+    /**
+     * Web Workers for browser environment
+     */
+    initializeWebWorkers() {
+        const workerCode = this.generateWebWorkerCode();
+        const workerBlob = new Blob([workerCode], { type: 'application/javascript' });
+        const workerUrl = URL.createObjectURL(workerBlob);
+        for (let i = 0; i < this.config.maxWorkers; i++) {
+            try {
+                const worker = new Worker(workerUrl);
+                this.setupWorkerHandlers(worker, i);
+                this.workers.push(worker);
+                this.stats.activeWorkers++;
+            }
+            catch (error) {
+                console.warn(`Failed to create worker ${i}:`, error);
+            }
+        }
+    }
+    /**
+     * Node.js worker_threads (placeholder - would need actual implementation)
+     */
+    initializeNodeWorkers() {
+        // TODO: Implement worker_threads for Node.js environment
+        // For now, fall back to simulation
+        this.initializeFallbackWorkers();
+    }
+    /**
+     * Fallback simulation for testing/development
+     */
+    initializeFallbackWorkers() {
+        // Simulate workers with async processing
+        for (let i = 0; i < this.config.maxWorkers; i++) {
+            const mockWorker = {
+                postMessage: (data) => {
+                    // Simulate async processing
+                    setTimeout(() => {
+                        this.handleWorkerMessage({
+                            data: {
+                                jobId: data.jobId,
+                                result: `Processed: ${JSON.stringify(data.payload)}`,
+                                success: true
+                            }
+                        });
+                    }, Math.random() * 100 + 50); // 50-150ms simulation
+                },
+                terminate: () => { },
+                addEventListener: () => { },
+                removeEventListener: () => { }
+            };
+            this.workers.push(mockWorker);
+            this.stats.activeWorkers++;
+        }
+    }
+    /**
+     * Generate Web Worker code for browser execution
+     */
+    generateWebWorkerCode() {
+        return `
+      // QNCE Thread Pool Worker
+      self.addEventListener('message', function(e) {
+        const { jobId, type, payload } = e.data;
+        
+        try {
+          let result;
+          
+          switch (type) {
+            case 'cache-load':
+              // Simulate cache loading
+              result = processCache(payload);
+              break;
+              
+            case 'telemetry-write':
+              // Simulate telemetry writing
+              result = writeTelemetryData(payload);
+              break;
+              
+            case 'hot-reload-prep':
+              // Simulate hot-reload preparation
+              result = prepareReload(payload);
+              break;
+              
+            case 'asset-process':
+              // Simulate asset processing
+              result = processAsset(payload);
+              break;
+              
+            default:
+              throw new Error('Unknown job type: ' + type);
+          }
+          
+          self.postMessage({
+            jobId,
+            result,
+            success: true
+          });
+          
+        } catch (error) {
+          self.postMessage({
+            jobId,
+            error: error.message,
+            success: false
+          });
+        }
+      });
+      
+      function processCache(payload) {
+        // Simulate cache processing work
+        const data = JSON.parse(JSON.stringify(payload));
+        return { cached: true, data, timestamp: Date.now() };
+      }
+      
+      function writeTelemetryData(payload) {
+        // Simulate telemetry write
+        return { written: true, bytes: JSON.stringify(payload).length };
+      }
+      
+      function prepareReload(payload) {
+        // Simulate hot-reload preparation
+        return { prepared: true, deltaSize: JSON.stringify(payload).length };
+      }
+      
+      function processAsset(payload) {
+        // Simulate asset processing
+        return { processed: true, asset: payload };
+      }
+    `;
+    }
+    /**
+     * Setup worker message handlers
+     */
+    setupWorkerHandlers(worker, workerId) {
+        worker.addEventListener('message', (e) => this.handleWorkerMessage(e));
+        worker.addEventListener('error', (e) => this.handleWorkerError(e, workerId));
+    }
+    /**
+     * Handle worker completion messages
+     */
+    handleWorkerMessage(event) {
+        const { jobId, result, error, success } = event.data;
+        const job = this.activeJobs.get(jobId);
+        if (!job)
+            return;
+        this.activeJobs.delete(jobId);
+        if (success) {
+            job.resolve(result);
+            this.stats.completedJobs++;
+        }
+        else {
+            job.reject(new Error(error));
+            this.stats.failedJobs++;
+        }
+        // Update execution time stats
+        const executionTime = performance.now() - job.timestamp;
+        this.updateExecutionTimeStats(executionTime);
+        // Process next job in queue
+        this.processQueue();
+    }
+    /**
+     * Handle worker errors
+     */
+    handleWorkerError(error, workerId) {
+        console.error(`Worker ${workerId} error:`, error);
+        // TODO: Implement worker recovery/restart logic
+    }
+    /**
+     * Process job queue by assigning jobs to available workers
+     */
+    processQueue() {
+        if (this.jobQueue.length === 0)
+            return;
+        const availableWorkers = this.config.maxWorkers - this.activeJobs.size;
+        if (availableWorkers <= 0)
+            return;
+        const job = this.jobQueue.shift();
+        this.stats.queuedJobs = this.jobQueue.length;
+        this.activeJobs.set(job.id, job);
+        // Find least busy worker (for now, just use round-robin)
+        const workerIndex = this.stats.completedJobs % this.workers.length;
+        const worker = this.workers[workerIndex];
+        worker.postMessage({
+            jobId: job.id,
+            type: job.type,
+            payload: job.payload
+        });
+    }
+    /**
+     * Find insertion index for job based on priority
+     */
+    findInsertionIndex(priority) {
+        const priorityValues = { high: 3, normal: 2, low: 1 };
+        const jobPriority = priorityValues[priority];
+        for (let i = 0; i < this.jobQueue.length; i++) {
+            if (priorityValues[this.jobQueue[i].priority] < jobPriority) {
+                return i;
+            }
+        }
+        return this.jobQueue.length;
+    }
+    /**
+     * Update execution time statistics
+     */
+    updateExecutionTimeStats(executionTime) {
+        const totalJobs = this.stats.completedJobs + this.stats.failedJobs;
+        this.stats.avgExecutionTime = ((this.stats.avgExecutionTime * (totalJobs - 1)) + executionTime) / totalJobs;
+        this.stats.workerUtilization = (this.activeJobs.size / this.config.maxWorkers) * 100;
+    }
+}
+exports.QnceThreadPool = QnceThreadPool;
+// Singleton instance for global access
+let globalThreadPool = null;
+function getThreadPool(config) {
+    if (!globalThreadPool) {
+        globalThreadPool = new QnceThreadPool(config);
+    }
+    return globalThreadPool;
+}
+function shutdownThreadPool() {
+    if (globalThreadPool) {
+        const shutdown = globalThreadPool.shutdown();
+        globalThreadPool = null;
+        return shutdown;
+    }
+    return Promise.resolve();
+}

package/dist/index.d.ts

@@ -1,4 +1,8 @@
 export * from './engine/core.js';
 export { DEMO_STORY } from './engine/demo-story.js';
+export * from './engine/condition.js';
+export * from './integrations/react.js';
+export * from './ui/index.js';
 export { QNCEEngine, createQNCEEngine, loadStoryData, type Choice, type NarrativeNode, type QNCEState, type StoryData } from './engine/core.js';
+export { ConditionEvaluator, ConditionEvaluationError, conditionEvaluator, type ConditionContext, type CustomEvaluatorFunction } from './engine/condition.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGpD,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,aAAa,EACb,KAAK,MAAM,EACX,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGpD,cAAc,uBAAuB,CAAC;AAGtC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,eAAe,CAAC;AAG9B,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,aAAa,EACb,KAAK,MAAM,EACX,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC7B,MAAM,uBAAuB,CAAC"}

package/dist/index.js

@@ -1,6 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conditionEvaluator = exports.ConditionEvaluationError = exports.ConditionEvaluator = exports.loadStoryData = exports.createQNCEEngine = exports.QNCEEngine = exports.DEMO_STORY = void 0;
 // QNCE Engine - Main Export
-export * from './engine/core.js';
-export { DEMO_STORY } from './engine/demo-story.js';
+__exportStar(require("./engine/core.js"), exports);
+var demo_story_js_1 = require("./engine/demo-story.js");
+Object.defineProperty(exports, "DEMO_STORY", { enumerable: true, get: function () { return demo_story_js_1.DEMO_STORY; } });
+// Sprint 3.4: Conditional choice display exports
+__exportStar(require("./engine/condition.js"), exports);
+// Sprint 3.5: React integration for autosave/undo functionality
+__exportStar(require("./integrations/react.js"), exports);
+// Sprint 3.6: UI Components
+__exportStar(require("./ui/index.js"), exports);
 // Re-export for convenience
-export { QNCEEngine, createQNCEEngine, loadStoryData } from './engine/core.js';
+var core_js_1 = require("./engine/core.js");
+Object.defineProperty(exports, "QNCEEngine", { enumerable: true, get: function () { return core_js_1.QNCEEngine; } });
+Object.defineProperty(exports, "createQNCEEngine", { enumerable: true, get: function () { return core_js_1.createQNCEEngine; } });
+Object.defineProperty(exports, "loadStoryData", { enumerable: true, get: function () { return core_js_1.loadStoryData; } });
+// Sprint 3.4: Conditional choice types
+var condition_js_1 = require("./engine/condition.js");
+Object.defineProperty(exports, "ConditionEvaluator", { enumerable: true, get: function () { return condition_js_1.ConditionEvaluator; } });
+Object.defineProperty(exports, "ConditionEvaluationError", { enumerable: true, get: function () { return condition_js_1.ConditionEvaluationError; } });
+Object.defineProperty(exports, "conditionEvaluator", { enumerable: true, get: function () { return condition_js_1.conditionEvaluator; } });
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEpD,4BAA4B;AAC5B,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,aAAa,EAKd,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,4BAA4B;AAC5B,mDAAiC;AACjC,wDAAoD;AAA3C,2GAAA,UAAU,OAAA;AAEnB,iDAAiD;AACjD,wDAAsC;AAEtC,gEAAgE;AAChE,0DAAwC;AAExC,4BAA4B;AAC5B,gDAA8B;AAE9B,4BAA4B;AAC5B,4CAQ0B;AAPxB,qGAAA,UAAU,OAAA;AACV,2GAAA,gBAAgB,OAAA;AAChB,wGAAA,aAAa,OAAA;AAOf,uCAAuC;AACvC,sDAM+B;AAL7B,kHAAA,kBAAkB,OAAA;AAClB,wHAAA,wBAAwB,OAAA;AACxB,kHAAA,kBAAkB,OAAA"}