qnce-engine 0.1.0 → 1.2.0

package/dist/narrative/branching/models.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Core branching entities for dynamic narrative flow management
+ * Built on Sprint #2 performance infrastructure with object pooling support
+ */
+import { NarrativeNode, QNCEState } from '../../engine/core';
+/**
+ * Top-level story container with branching metadata
+ */
+export interface QNCEStory {
+    id: string;
+    title: string;
+    version: string;
+    metadata: StoryMetadata;
+    chapters: Chapter[];
+    branchingConfig: BranchingConfig;
+}
+export interface StoryMetadata {
+    author: string;
+    description: string;
+    tags: string[];
+    createDate: Date;
+    lastModified: Date;
+    estimatedPlaytime: number;
+}
+export interface BranchingConfig {
+    maxActiveBranches: number;
+    branchCacheSize: number;
+    enableDynamicInsertion: boolean;
+    enableAnalytics: boolean;
+    performanceMode: boolean;
+}
+/**
+ * Chapter: Logical grouping of narrative flows with branching points
+ */
+export interface Chapter {
+    id: string;
+    title: string;
+    description?: string;
+    flows: NarrativeFlow[];
+    branches: BranchPoint[];
+    prerequisites?: ChapterPrerequisites;
+    metadata: ChapterMetadata;
+}
+export interface ChapterPrerequisites {
+    requiredFlags: Record<string, unknown>;
+    requiredChoices: string[];
+    minPlaytime?: number;
+}
+export interface ChapterMetadata {
+    difficulty: 'easy' | 'medium' | 'hard';
+    themes: string[];
+    estimatedDuration: number;
+    branchComplexity: number;
+}
+/**
+ * NarrativeFlow: Sequence of connected nodes with entry/exit points
+ */
+export interface NarrativeFlow {
+    id: string;
+    name: string;
+    description?: string;
+    nodes: NarrativeNode[];
+    entryPoints: FlowEntryPoint[];
+    exitPoints: FlowExitPoint[];
+    flowType: FlowType;
+    metadata: FlowMetadata;
+}
+export type FlowType = 'linear' | 'branching' | 'conditional' | 'procedural';
+export interface FlowEntryPoint {
+    id: string;
+    nodeId: string;
+    conditions?: BranchCondition[];
+    priority: number;
+}
+export interface FlowExitPoint {
+    id: string;
+    nodeId: string;
+    targetFlowId?: string;
+    conditions?: BranchCondition[];
+}
+export interface FlowMetadata {
+    complexity: number;
+    avgCompletionTime: number;
+    playerChoiceCount: number;
+    aiGeneratedContent: boolean;
+}
+/**
+ * BranchPoint: Dynamic branching logic between flows
+ */
+export interface BranchPoint {
+    id: string;
+    name: string;
+    sourceFlowId: string;
+    sourceNodeId: string;
+    branchOptions: BranchOption[];
+    branchType: BranchType;
+    conditions?: BranchCondition[];
+    metadata: BranchMetadata;
+}
+export type BranchType = 'choice-driven' | 'flag-conditional' | 'time-based' | 'procedural' | 'conditional';
+export interface BranchOption {
+    id: string;
+    targetFlowId: string;
+    targetNodeId?: string;
+    displayText: string;
+    conditions?: BranchCondition[];
+    flagEffects?: Record<string, unknown>;
+    weight: number;
+}
+export interface BranchCondition {
+    type: 'flag' | 'choice' | 'time' | 'random' | 'custom';
+    operator: 'equals' | 'not_equals' | 'greater' | 'less' | 'contains' | 'exists';
+    key: string;
+    value: unknown;
+    evaluator?: (state: QNCEState, context: BranchContext) => boolean;
+}
+export interface BranchMetadata {
+    usageCount: number;
+    avgTraversalTime: number;
+    playerPreference: number;
+    lastUsed: Date;
+}
+/**
+ * BranchContext: Runtime state for branch evaluation and tracking
+ */
+export interface BranchContext {
+    currentStory: QNCEStory;
+    currentChapter: Chapter;
+    currentFlow: NarrativeFlow;
+    activeState: QNCEState;
+    branchHistory: BranchHistoryEntry[];
+    pendingBranches: PendingBranch[];
+    analytics: BranchAnalytics;
+}
+export interface BranchHistoryEntry {
+    id: string;
+    branchPointId: string;
+    chosenOptionId: string;
+    timestamp: Date;
+    executionTime: number;
+    context: Partial<QNCEState>;
+}
+export interface PendingBranch {
+    id: string;
+    branchPointId: string;
+    triggerConditions: BranchCondition[];
+    timeoutMs?: number;
+    createdAt: Date;
+}
+export interface BranchAnalytics {
+    totalBranchesTraversed: number;
+    avgBranchDecisionTime: number;
+    mostPopularBranches: string[];
+    abandonmentPoints: string[];
+    completionRate: number;
+    sessionStartTime: Date;
+}
+/**
+ * Dynamic branching operations for runtime story modification
+ */
+export interface DynamicBranchOperation {
+    type: 'insert' | 'remove' | 'modify';
+    branchId: string;
+    targetLocation: BranchLocation;
+    payload?: Partial<BranchPoint>;
+    conditions?: BranchCondition[];
+}
+export interface BranchLocation {
+    chapterId: string;
+    flowId: string;
+    nodeId: string;
+    insertionPoint: 'before' | 'after' | 'replace';
+}
+/**
+ * Dynamic flow insertion for procedural content
+ */
+export interface DynamicFlowOperation {
+    type: 'insert' | 'remove' | 'modify';
+    flowId: string;
+    targetChapterId: string;
+    flow?: NarrativeFlow;
+    entryConditions?: BranchCondition[];
+}
+/**
+ * Pool-aware branch entities for performance optimization
+ */
+export interface PooledBranchContext extends BranchContext {
+    poolId: string;
+    acquisitionTime: number;
+    maxLifetime: number;
+}
+export interface PooledBranchPoint extends BranchPoint {
+    poolId: string;
+    activeReferences: number;
+    lastAccessed: number;
+}
+/**
+ * Interfaces for AI-driven content generation and branching
+ */
+export interface AIBranchingContext {
+    playerProfile: PlayerProfile;
+    narrativeContext: NarrativeContext;
+    generationHints: AIGenerationHints;
+}
+export interface PlayerProfile {
+    playStyle: 'explorer' | 'achiever' | 'socializer' | 'killer';
+    preferences: Record<string, number>;
+    historicalChoices: string[];
+    averageDecisionTime: number;
+}
+export interface NarrativeContext {
+    currentTone: string;
+    thematicElements: string[];
+    characterRelationships: Record<string, number>;
+    plotTension: number;
+}
+export interface AIGenerationHints {
+    maxBranchDepth: number;
+    desiredComplexity: number;
+    contentThemes: string[];
+    avoidElements: string[];
+}
+//# sourceMappingURL=models.d.ts.map

package/dist/narrative/branching/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../src/narrative/branching/models.ts"],"names":[],"mappings":"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"}

package/dist/narrative/branching/models.js

@@ -0,0 +1,6 @@
+"use strict";
+// QNCE Branching System - Platform Data Model (PDM)
+// Sprint #3 - Advanced Narrative & AI Integration
+Object.defineProperty(exports, "__esModule", { value: true });
+// All interfaces are exported above and ready for engine integration
+//# sourceMappingURL=models.js.map

package/dist/narrative/branching/models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../src/narrative/branching/models.ts"],"names":[],"mappings":";AAAA,oDAAoD;AACpD,kDAAkD;;AAuRlD,qEAAqE"}

package/dist/performance/HotReloadDelta.d.ts

@@ -0,0 +1,107 @@
+export interface StoryDelta {
+    nodeChanges: NodeDelta[];
+    assetChanges: AssetDelta[];
+    timestamp: number;
+}
+export interface NodeDelta {
+    nodeId: string;
+    changeType: 'added' | 'modified' | 'removed';
+    oldNode?: any;
+    newNode?: any;
+    affectedFields: string[];
+}
+export interface AssetDelta {
+    assetId: string;
+    changeType: 'added' | 'modified' | 'removed';
+    oldAsset?: any;
+    newAsset?: any;
+    sizeChange: number;
+}
+/**
+ * Delta Comparison Engine for Hot-Reload Story Updates
+ * Identifies minimal changes needed to update narrative content
+ */
+export declare class StoryDeltaComparator {
+    /**
+     * Compare two story configurations and generate delta
+     */
+    compareStories(oldStory: any, newStory: any): StoryDelta;
+    /**
+     * Deep comparison of narrative nodes
+     */
+    private compareNodes;
+    /**
+     * Compare assets (future: images, audio, etc.)
+     */
+    private compareAssets;
+    /**
+     * Fine-grained field comparison for nodes
+     */
+    private findChangedFields;
+    /**
+     * Asset comparison logic
+     */
+    private assetsAreDifferent;
+    /**
+     * Deep equality check for objects
+     */
+    private deepEqual;
+}
+/**
+ * Hot-Reload Delta Patcher
+ * Applies story deltas with minimal engine disruption
+ */
+export declare class StoryDeltaPatcher {
+    private engine;
+    constructor(engine: any);
+    /**
+     * Apply delta patch to running engine
+     * Target: <2ms frame stall for hot-reload
+     */
+    applyDelta(delta: StoryDelta): Promise<PatchResult>;
+    /**
+     * Validate delta is safe to apply
+     */
+    private validateDelta;
+    /**
+     * Apply node changes to story data
+     */
+    private applyNodeChanges;
+    /**
+     * Fast synchronous node changes for small deltas (no async overhead)
+     */
+    private applyNodeChangesFast;
+    /**
+     * Apply asset changes (placeholder for future implementation)
+     */
+    private applyAssetChanges;
+    /**
+     * Batch node changes by type for efficient processing
+     */
+    private batchNodeChanges;
+    /**
+     * Process a batch of node changes
+     */
+    private processBatch;
+    /**
+     * Apply individual node change
+     */
+    private applyNodeChange;
+    /**
+     * Refresh engine state after patch
+     */
+    private refreshEngineState;
+}
+export interface PatchResult {
+    success: boolean;
+    patchId: string;
+    duration: number;
+    nodesChanged?: number;
+    assetsChanged?: number;
+    error?: string;
+}
+export declare function createDeltaTools(engine: any): {
+    comparator: StoryDeltaComparator;
+    patcher: StoryDeltaPatcher;
+};
+//# sourceMappingURL=HotReloadDelta.d.ts.map

package/dist/performance/HotReloadDelta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HotReloadDelta.d.ts","sourceRoot":"","sources":["../../src/performance/HotReloadDelta.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,SAAS,EAAE,CAAC;IACzB,YAAY,EAAE,UAAU,EAAE,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;IAC7C,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,EAAE,GAAG,CAAC;IACf,QAAQ,CAAC,EAAE,GAAG,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,qBAAa,oBAAoB;IAE/B;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,GAAG,UAAU;IAUxD;;OAEG;IACH,OAAO,CAAC,YAAY;IA+CpB;;OAEG;IACH,OAAO,CAAC,aAAa;IA4CrB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAazB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAK1B;;OAEG;IACH,OAAO,CAAC,SAAS;CAuBlB;AAED;;;GAGG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAM;gBAER,MAAM,EAAE,GAAG;IAIvB;;;OAGG;IACG,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC;IAmDzD;;OAEG;IACH,OAAO,CAAC,aAAa;IAgBrB;;OAEG;YACW,gBAAgB;IAS9B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAM5B;;OAEG;YACW,iBAAiB;IAK/B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;OAEG;YACW,YAAY;IAY1B;;OAEG;IACH,OAAO,CAAC,eAAe;IAgCvB;;OAEG;IACH,OAAO,CAAC,kBAAkB;CAI3B;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAGD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,GAAG;;;EAK3C"}

package/dist/performance/HotReloadDelta.js

@@ -0,0 +1,333 @@
+"use strict";
+// S2-T3: Hot-Reload Delta Patching - Initial Spike
+// Explore delta comparison logic for story content updates
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoryDeltaPatcher = exports.StoryDeltaComparator = void 0;
+exports.createDeltaTools = createDeltaTools;
+/**
+ * Delta Comparison Engine for Hot-Reload Story Updates
+ * Identifies minimal changes needed to update narrative content
+ */
+class StoryDeltaComparator {
+    /**
+     * Compare two story configurations and generate delta
+     */
+    compareStories(oldStory, newStory) {
+        const timestamp = performance.now();
+        return {
+            nodeChanges: this.compareNodes(oldStory.nodes || [], newStory.nodes || []),
+            assetChanges: this.compareAssets(oldStory.assets || [], newStory.assets || []),
+            timestamp
+        };
+    }
+    /**
+     * Deep comparison of narrative nodes
+     */
+    compareNodes(oldNodes, newNodes) {
+        const deltas = [];
+        const oldNodeMap = new Map(oldNodes.map(n => [n.id, n]));
+        const newNodeMap = new Map(newNodes.map(n => [n.id, n]));
+        // Check for removed nodes
+        for (const [nodeId, oldNode] of oldNodeMap) {
+            if (!newNodeMap.has(nodeId)) {
+                deltas.push({
+                    nodeId,
+                    changeType: 'removed',
+                    oldNode,
+                    affectedFields: ['*']
+                });
+            }
+        }
+        // Check for added and modified nodes
+        for (const [nodeId, newNode] of newNodeMap) {
+            const oldNode = oldNodeMap.get(nodeId);
+            if (!oldNode) {
+                // New node
+                deltas.push({
+                    nodeId,
+                    changeType: 'added',
+                    newNode,
+                    affectedFields: ['*']
+                });
+            }
+            else {
+                // Check for modifications
+                const affectedFields = this.findChangedFields(oldNode, newNode);
+                if (affectedFields.length > 0) {
+                    deltas.push({
+                        nodeId,
+                        changeType: 'modified',
+                        oldNode,
+                        newNode,
+                        affectedFields
+                    });
+                }
+            }
+        }
+        return deltas;
+    }
+    /**
+     * Compare assets (future: images, audio, etc.)
+     */
+    compareAssets(oldAssets, newAssets) {
+        const deltas = [];
+        const oldAssetMap = new Map(oldAssets.map(a => [a.id, a]));
+        const newAssetMap = new Map(newAssets.map(a => [a.id, a]));
+        // Check for removed assets
+        for (const [assetId, oldAsset] of oldAssetMap) {
+            if (!newAssetMap.has(assetId)) {
+                deltas.push({
+                    assetId,
+                    changeType: 'removed',
+                    oldAsset,
+                    sizeChange: -(oldAsset.size || 0)
+                });
+            }
+        }
+        // Check for added and modified assets
+        for (const [assetId, newAsset] of newAssetMap) {
+            const oldAsset = oldAssetMap.get(assetId);
+            if (!oldAsset) {
+                // New asset
+                deltas.push({
+                    assetId,
+                    changeType: 'added',
+                    newAsset,
+                    sizeChange: newAsset.size || 0
+                });
+            }
+            else if (this.assetsAreDifferent(oldAsset, newAsset)) {
+                // Modified asset
+                deltas.push({
+                    assetId,
+                    changeType: 'modified',
+                    oldAsset,
+                    newAsset,
+                    sizeChange: (newAsset.size || 0) - (oldAsset.size || 0)
+                });
+            }
+        }
+        return deltas;
+    }
+    /**
+     * Fine-grained field comparison for nodes
+     */
+    findChangedFields(oldNode, newNode) {
+        const changedFields = [];
+        const allFields = new Set([...Object.keys(oldNode), ...Object.keys(newNode)]);
+        for (const field of allFields) {
+            if (!this.deepEqual(oldNode[field], newNode[field])) {
+                changedFields.push(field);
+            }
+        }
+        return changedFields;
+    }
+    /**
+     * Asset comparison logic
+     */
+    assetsAreDifferent(oldAsset, newAsset) {
+        // Simple comparison - in practice, would use checksums/hashes
+        return JSON.stringify(oldAsset) !== JSON.stringify(newAsset);
+    }
+    /**
+     * Deep equality check for objects
+     */
+    deepEqual(a, b) {
+        if (a === b)
+            return true;
+        if (a === null || b === null)
+            return false;
+        if (typeof a !== typeof b)
+            return false;
+        if (typeof a === 'object') {
+            if (Array.isArray(a) !== Array.isArray(b))
+                return false;
+            const keysA = Object.keys(a);
+            const keysB = Object.keys(b);
+            if (keysA.length !== keysB.length)
+                return false;
+            for (const key of keysA) {
+                if (!keysB.includes(key))
+                    return false;
+                if (!this.deepEqual(a[key], b[key]))
+                    return false;
+            }
+            return true;
+        }
+        return false;
+    }
+}
+exports.StoryDeltaComparator = StoryDeltaComparator;
+/**
+ * Hot-Reload Delta Patcher
+ * Applies story deltas with minimal engine disruption
+ */
+class StoryDeltaPatcher {
+    engine;
+    constructor(engine) {
+        this.engine = engine;
+    }
+    /**
+     * Apply delta patch to running engine
+     * Target: <2ms frame stall for hot-reload
+     */
+    async applyDelta(delta) {
+        const startTime = performance.now();
+        const patchId = `patch-${Date.now()}`;
+        try {
+            // Phase 1: Validate delta can be applied safely (sync, fast)
+            const validation = this.validateDelta(delta);
+            if (!validation.safe) {
+                return {
+                    success: false,
+                    patchId,
+                    duration: performance.now() - startTime,
+                    error: validation.error
+                };
+            }
+            // Phase 2: Apply changes synchronously for speed
+            // For small deltas (<10 changes), apply immediately
+            // For larger deltas, use optimized batch processing
+            if (delta.nodeChanges.length <= 10) {
+                this.applyNodeChangesFast(delta.nodeChanges);
+            }
+            else {
+                await this.applyNodeChanges(delta.nodeChanges);
+            }
+            // Phase 3: Skip asset changes for now (async operation)
+            // Assets can be updated in background without frame stall
+            // Phase 4: Minimal state refresh
+            this.refreshEngineState();
+            const duration = performance.now() - startTime;
+            return {
+                success: true,
+                patchId,
+                duration,
+                nodesChanged: delta.nodeChanges.length,
+                assetsChanged: delta.assetChanges.length
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                patchId,
+                duration: performance.now() - startTime,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Validate delta is safe to apply
+     */
+    validateDelta(delta) {
+        // Check if current node would be affected
+        const currentNodeId = this.engine.getState().currentNodeId;
+        const currentNodeChange = delta.nodeChanges.find(c => c.nodeId === currentNodeId);
+        if (currentNodeChange && currentNodeChange.changeType === 'removed') {
+            return {
+                safe: false,
+                error: 'Cannot remove currently active node'
+            };
+        }
+        // Additional safety checks could go here
+        return { safe: true };
+    }
+    /**
+     * Apply node changes to story data
+     */
+    async applyNodeChanges(nodeChanges) {
+        // Batch node changes to minimize engine updates
+        const batches = this.batchNodeChanges(nodeChanges);
+        for (const batch of batches) {
+            await this.processBatch(batch);
+        }
+    }
+    /**
+     * Fast synchronous node changes for small deltas (no async overhead)
+     */
+    applyNodeChangesFast(nodeChanges) {
+        for (const change of nodeChanges) {
+            this.applyNodeChange(change);
+        }
+    }
+    /**
+     * Apply asset changes (placeholder for future implementation)
+     */
+    async applyAssetChanges(assetChanges) {
+        // Future: Implement asset hot-reload
+        console.log(`Would apply ${assetChanges.length} asset changes`);
+    }
+    /**
+     * Batch node changes by type for efficient processing
+     */
+    batchNodeChanges(nodeChanges) {
+        const batches = [];
+        const batchSize = 25; // Larger batch size for efficiency
+        for (let i = 0; i < nodeChanges.length; i += batchSize) {
+            batches.push(nodeChanges.slice(i, i + batchSize));
+        }
+        return batches;
+    }
+    /**
+     * Process a batch of node changes
+     */
+    async processBatch(batch) {
+        // Use requestAnimationFrame or setTimeout to yield control
+        return new Promise(resolve => {
+            setTimeout(() => {
+                for (const change of batch) {
+                    this.applyNodeChange(change);
+                }
+                resolve();
+            }, 0);
+        });
+    }
+    /**
+     * Apply individual node change
+     */
+    applyNodeChange(change) {
+        // Access engine's internal story data
+        const storyData = this.engine.storyData;
+        switch (change.changeType) {
+            case 'added':
+                storyData.nodes.push(change.newNode);
+                break;
+            case 'removed':
+                const removeIndex = storyData.nodes.findIndex((n) => n.id === change.nodeId);
+                if (removeIndex >= 0) {
+                    storyData.nodes.splice(removeIndex, 1);
+                }
+                break;
+            case 'modified':
+                const modifyIndex = storyData.nodes.findIndex((n) => n.id === change.nodeId);
+                if (modifyIndex >= 0) {
+                    // Only update changed fields for minimal disruption
+                    for (const field of change.affectedFields) {
+                        if (field === '*') {
+                            storyData.nodes[modifyIndex] = change.newNode;
+                        }
+                        else {
+                            storyData.nodes[modifyIndex][field] = change.newNode[field];
+                        }
+                    }
+                }
+                break;
+        }
+    }
+    /**
+     * Refresh engine state after patch
+     */
+    refreshEngineState() {
+        // Minimal state refresh - avoid full reinitialization
+        // Future: Could trigger cache invalidation, UI updates, etc.
+    }
+}
+exports.StoryDeltaPatcher = StoryDeltaPatcher;
+// Factory function for creating delta tools
+function createDeltaTools(engine) {
+    return {
+        comparator: new StoryDeltaComparator(),
+        patcher: new StoryDeltaPatcher(engine)
+    };
+}
+//# sourceMappingURL=HotReloadDelta.js.map