@stream44.studio/encapsulate 0.2.0-rc.2 → 0.2.0-rc.4

package/src/static-analyzer.v0.ts

@@ -22,25 +22,25 @@ const ENCAPSULATE_MODULE_EXPORTS = new Set([
 async function constructNpmUri(absoluteFilepath: string, spineRoot: string): Promise<string | null> {
     let currentDir = dirname(absoluteFilepath)
     const maxDepth = 20 // Prevent infinite loops
-    
+
     for (let i = 0; i < maxDepth; i++) {
         const packageJsonPath = join(currentDir, 'package.json')
-        
+
         try {
             await stat(packageJsonPath)
             // Found package.json, read it
             const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8'))
             const packageName = packageJson.name
-            
+
             if (!packageName) {
                 // No name in package.json, continue searching
                 currentDir = dirname(currentDir)
                 continue
             }
-            
+
             // Get the relative path from the package root to the file
             const relativeFromPackage = relative(currentDir, absoluteFilepath)
-            
+
             // Construct npm URI: packageName/relativePath
             return `${packageName}/${relativeFromPackage}`
         } catch (error) {
@@ -53,7 +53,7 @@ async function constructNpmUri(absoluteFilepath: string, spineRoot: string): Pro
             currentDir = parentDir
         }
     }
-    
+
     return null
 }
 
@@ -63,6 +63,12 @@ const MODULE_GLOBAL_BUILTINS = new Set([
 
     'process',
 
+    // Bun runtime
+    'Bun',
+
+    // Node.js Buffer
+    'Buffer',
+
     // Console API
     'console',
 
@@ -186,7 +192,7 @@ export function StaticAnalyzer({
         parseModule: async ({ spineOptions, encapsulateOptions }: { spineOptions: any, encapsulateOptions: any }) => {
 
             const moduleFilepath = join(spineOptions.spineFilesystemRoot, encapsulateOptions.moduleFilepath)
-            
+
             // Determine the cache file path based on whether the module is external or internal
             let cacheFilePath: string
             if (encapsulateOptions.moduleFilepath.startsWith('../')) {
@@ -202,7 +208,7 @@ export function StaticAnalyzer({
                 // Internal module - use relative path as-is
                 cacheFilePath = encapsulateOptions.moduleFilepath
             }
-            
+
             const capsuleSourceLineRef = `${cacheFilePath}:${encapsulateOptions.importStackLine}`
 
             // Try to load from cache first
@@ -306,16 +312,16 @@ export function StaticAnalyzer({
 
                     // Construct npm URI for the module - try for all modules
                     let moduleUri: string | null = await constructNpmUri(moduleFilepath, spineOptions.spineFilesystemRoot)
-                    
+
                     // If npm URI construction failed, fall back to moduleFilepath
                     if (!moduleUri) {
                         moduleUri = encapsulateOptions.moduleFilepath
                     }
-                    
+
                     // Strip file extension from URI
                     const moduleUriWithoutExt = moduleUri.replace(/\.(ts|tsx|js|jsx)$/, '')
                     const capsuleSourceUriLineRef = `${moduleUriWithoutExt}:${encapsulateOptions.importStackLine}`
-                    
+
                     // Store moduleUri without extension
                     moduleUri = moduleUriWithoutExt
 
@@ -371,6 +377,21 @@ export function StaticAnalyzer({
                             const optionsEndPos = sourceFile.getLineAndCharacterOfPosition(optionsObject.getEnd())
                             cst.source.optionsStartLine = optionsStartPos.line + 1
                             cst.source.optionsEndLine = optionsEndPos.line + 1
+
+                            // Extract extendsCapsule option if present
+                            for (const prop of optionsObject.properties) {
+                                if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === 'extendsCapsule') {
+                                    // Check if it's a string literal (relative path or npm URI)
+                                    if (ts.isStringLiteral(prop.initializer)) {
+                                        cst.source.extendsCapsule = prop.initializer.text
+                                    }
+                                    // Check if it's an identifier (capsule variable reference)
+                                    else if (ts.isIdentifier(prop.initializer)) {
+                                        cst.source.extendsCapsule = prop.initializer.text
+                                    }
+                                    break
+                                }
+                            }
                         }
 
                         // Parse spineContract definitions (e.g., '$spineContract1': { ... })
@@ -423,6 +444,15 @@ export function StaticAnalyzer({
                                                         }
                                                     }
 
+                                                    // Check for 'as' property at the property contract level
+                                                    for (const contractProp of propValue.properties) {
+                                                        if (ts.isPropertyAssignment(contractProp) && ts.isIdentifier(contractProp.name) && contractProp.name.text === 'as') {
+                                                            if (ts.isStringLiteral(contractProp.initializer)) {
+                                                                spineContractDef.properties[propName].as = contractProp.initializer.text
+                                                            }
+                                                        }
+                                                    }
+
                                                     // Parse properties within the property contract
                                                     for (const contractProp of propValue.properties) {
                                                         if (ts.isPropertyAssignment(contractProp) && (ts.isIdentifier(contractProp.name) || ts.isStringLiteral(contractProp.name))) {
@@ -533,7 +563,9 @@ export function StaticAnalyzer({
 
                                 // Add a dynamic mapping for each non-default property contract
                                 for (const propContractUri of nonDefaultContracts) {
-                                    const contractKey = '#' + propContractUri.substring(1)
+                                    // Check if 'as' alias is defined for this property contract
+                                    const aliasName = spineContract.properties[propContractUri]?.as
+                                    const contractKey = aliasName || ('#' + propContractUri.substring(1))
                                     spineContract.properties['#'].properties[contractKey] = {
                                         declarationLine: -1,
                                         definitionStartLine: -1,
@@ -541,7 +573,8 @@ export function StaticAnalyzer({
                                         type: 'CapsulePropertyTypes.Mapping',
                                         valueType: 'string',
                                         valueExpression: `"${propContractUri.substring(1)}"`,
-                                        propertyContractDelegate: propContractUri
+                                        propertyContractDelegate: propContractUri,
+                                        as: aliasName
                                     }
                                 }
                             }
@@ -777,7 +810,7 @@ function extractFunctionSignature(fn: ts.FunctionExpression | ts.ArrowFunction,
     return `(${params.join(', ')}) => ${returnType}`
 }
 
-// Extract module-local functions that are self-contained
+// Extract module-local functions and variables that are self-contained
 function extractModuleLocalCode(
     ambientReferences: Record<string, any>,
     sourceFile: ts.SourceFile,
@@ -787,12 +820,21 @@ function extractModuleLocalCode(
 ): Record<string, string> {
     const moduleLocalCode: Record<string, string> = {}
     const moduleLocalFunctions = new Map<string, ts.FunctionDeclaration>()
+    const moduleLocalVariables = new Map<string, ts.VariableDeclaration>()
 
-    // First, collect all top-level function declarations in the module (including async functions)
+    // First, collect all top-level function declarations and variable declarations in the module
     for (const statement of sourceFile.statements) {
         if (ts.isFunctionDeclaration(statement) && statement.name) {
             moduleLocalFunctions.set(statement.name.text, statement)
         }
+        // Collect module-level variable declarations
+        if (ts.isVariableStatement(statement)) {
+            for (const decl of statement.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name)) {
+                    moduleLocalVariables.set(decl.name.text, decl)
+                }
+            }
+        }
     }
 
     // Also collect functions from the local scope around the call node
@@ -813,7 +855,7 @@ function extractModuleLocalCode(
         }
     }
 
-    // Check each ambient reference to see if it's a module-local function
+    // Check each ambient reference to see if it's a module-local function or variable
     for (const [name, ref] of Object.entries(ambientReferences)) {
         const refTyped = ref as any
 
@@ -824,45 +866,68 @@ function extractModuleLocalCode(
 
         // Check if this identifier refers to a module-local function
         const funcDecl = moduleLocalFunctions.get(name)
-        if (!funcDecl) continue
-
-        // Analyze the function to see if it's self-contained
-        const dependencies = new Set<string>()
-        const isContained = analyzeFunctionDependencies(funcDecl, sourceFile, importMap, assignmentMap, moduleLocalFunctions, dependencies)
-
-        if (isContained) {
-            // Mark this as module-local in ambient references
-            refTyped.type = 'module-local'
-
-            // Collect the function code and all its dependencies
-            const collectedCode: string[] = []
-            const processed = new Set<string>()
-
-            function collectFunction(fnName: string) {
-                if (processed.has(fnName)) return
-                processed.add(fnName)
-
-                const fn = moduleLocalFunctions.get(fnName)
-                if (fn) {
-                    const fnCode = fn.getText(sourceFile)
-                    collectedCode.push(fnCode)
-                    // Also add each function as a separate entry in moduleLocalCode
-                    if (!moduleLocalCode[fnName]) {
-                        moduleLocalCode[fnName] = fnCode
+        if (funcDecl) {
+            // Analyze the function to see if it's self-contained
+            const dependencies = new Set<string>()
+            const isContained = analyzeFunctionDependencies(funcDecl, sourceFile, importMap, assignmentMap, moduleLocalFunctions, dependencies)
+
+            if (isContained) {
+                // Mark this as module-local in ambient references
+                refTyped.type = 'module-local'
+
+                // Collect the function code and all its dependencies
+                const collectedCode: string[] = []
+                const processed = new Set<string>()
+
+                function collectFunction(fnName: string) {
+                    if (processed.has(fnName)) return
+                    processed.add(fnName)
+
+                    const fn = moduleLocalFunctions.get(fnName)
+                    if (fn) {
+                        const fnCode = fn.getText(sourceFile)
+                        collectedCode.push(fnCode)
+                        // Also add each function as a separate entry in moduleLocalCode
+                        if (!moduleLocalCode[fnName]) {
+                            moduleLocalCode[fnName] = fnCode
+                        }
                     }
                 }
-            }
 
-            // Collect the main function
-            collectFunction(name)
+                // Collect the main function
+                collectFunction(name)
+
+                // Collect all dependencies
+                for (const dep of dependencies) {
+                    collectFunction(dep)
+                }
 
-            // Collect all dependencies
-            for (const dep of dependencies) {
-                collectFunction(dep)
+                // Store the collected code (main function with all dependencies)
+                moduleLocalCode[name] = collectedCode.join('\n\n')
             }
+            continue
+        }
 
-            // Store the collected code (main function with all dependencies)
-            moduleLocalCode[name] = collectedCode.join('\n\n')
+        // Check if this identifier refers to a module-local variable
+        const varDecl = moduleLocalVariables.get(name)
+        if (varDecl) {
+            // Analyze the variable to see if it's self-contained
+            const varDependencies = analyzeVariableDependencies(varDecl, sourceFile, importMap, assignmentMap, moduleLocalFunctions, moduleLocalVariables)
+
+            if (varDependencies.isContained) {
+                // Mark this as module-local in ambient references
+                refTyped.type = 'module-local'
+
+                // Get the variable declaration code
+                // We need to get the full variable statement (const/let/var KEYS_DIR = ...)
+                const varStatement = varDecl.parent?.parent
+                if (varStatement && ts.isVariableStatement(varStatement)) {
+                    moduleLocalCode[name] = varStatement.getText(sourceFile)
+                } else {
+                    // Fallback to just the declaration
+                    moduleLocalCode[name] = varDecl.getText(sourceFile)
+                }
+            }
         }
     }
 
@@ -961,6 +1026,11 @@ function analyzeFunctionDependencies(
 
     // Second pass: check for external dependencies
     function visit(node: ts.Node, currentScope: Set<string> = localIdentifiers) {
+        // Skip type nodes to avoid false positives from type annotations
+        if (ts.isTypeNode(node)) {
+            return
+        }
+
         // Use the appropriate scope for nested functions
         if (nestedFunctionScopes.has(node)) {
             currentScope = nestedFunctionScopes.get(node)!
@@ -1028,6 +1098,92 @@ function analyzeFunctionDependencies(
     return isContained
 }
 
+// Analyze if a variable declaration is self-contained (only depends on imports and builtins)
+// Returns whether it's contained and the import dependencies needed
+function analyzeVariableDependencies(
+    varDecl: ts.VariableDeclaration,
+    sourceFile: ts.SourceFile,
+    importMap: Map<string, { importSpecifier: string, moduleUri: string }>,
+    assignmentMap: Map<string, { importSpecifier: string, moduleUri: string }>,
+    moduleLocalFunctions: Map<string, ts.FunctionDeclaration>,
+    moduleLocalVariables: Map<string, ts.VariableDeclaration>
+): { isContained: boolean, importDependencies: Map<string, { importSpecifier: string, moduleUri: string }> } {
+    const importDependencies = new Map<string, { importSpecifier: string, moduleUri: string }>()
+    let isContained = true
+
+    if (!varDecl.initializer) {
+        // No initializer means it's just a declaration, treat as contained
+        return { isContained: true, importDependencies }
+    }
+
+    function visit(node: ts.Node) {
+        // Skip type nodes
+        if (ts.isTypeNode(node)) {
+            return
+        }
+
+        if (ts.isIdentifier(node)) {
+            const identifierName = node.text
+
+            // Skip special keywords
+            if (identifierName === 'this' || identifierName === 'undefined' || identifierName === 'null') {
+                return
+            }
+
+            // Skip property access names
+            const parent = node.parent
+            if (parent && ts.isPropertyAccessExpression(parent) && parent.name === node) {
+                return
+            }
+
+            // Skip property names in object literals
+            if (parent && ts.isPropertyAssignment(parent) && parent.name === node) {
+                return
+            }
+
+            // Check if it's an import - track as dependency
+            const importInfo = importMap.get(identifierName)
+            if (importInfo) {
+                importDependencies.set(identifierName, importInfo)
+                return
+            }
+
+            // Check if it's an assignment from import
+            const assignmentInfo = assignmentMap.get(identifierName)
+            if (assignmentInfo) {
+                importDependencies.set(identifierName, assignmentInfo)
+                return
+            }
+
+            // Check if it's a module-global builtin - allowed
+            if (MODULE_GLOBAL_BUILTINS.has(identifierName)) {
+                return
+            }
+
+            // Check if it's another module-local variable - recursively analyze
+            if (moduleLocalVariables.has(identifierName)) {
+                // For now, allow references to other module-local variables
+                // A more complete implementation would recursively analyze
+                return
+            }
+
+            // Check if it's a module-local function - allowed
+            if (moduleLocalFunctions.has(identifierName)) {
+                return
+            }
+
+            // Unknown external reference - not self-contained
+            isContained = false
+        }
+
+        ts.forEachChild(node, visit)
+    }
+
+    visit(varDecl.initializer)
+
+    return { isContained, importDependencies }
+}
+
 // Helper to extract binding identifiers for analysis
 function extractBindingIdentifiersForAnalysis(name: ts.BindingName, targetSet: Set<string>) {
     if (ts.isIdentifier(name)) {
@@ -1060,13 +1216,21 @@ function extractCapsuleAmbientReferences(
     const propertyNames = new Set<string>()
     const invocationParameters = new Set<string>()
     const moduleLocalFunctions = new Map<string, ts.FunctionDeclaration>()
+    const moduleLocalVariables = new Map<string, ts.VariableDeclaration>()
 
-    // Collect module-local functions from both module top-level and local scope
-    // First, collect top-level module functions
+    // Collect module-local functions and variables from module top-level
     for (const statement of sourceFile.statements) {
         if (ts.isFunctionDeclaration(statement) && statement.name) {
             moduleLocalFunctions.set(statement.name.text, statement)
         }
+        // Collect module-level variable declarations
+        if (ts.isVariableStatement(statement)) {
+            for (const decl of statement.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name)) {
+                    moduleLocalVariables.set(decl.name.text, decl)
+                }
+            }
+        }
     }
 
     // Find enclosing function and collect its parameters and local functions
@@ -1235,6 +1399,32 @@ function extractCapsuleAmbientReferences(
                         }
                     }
 
+                    // Check if it's a module-local variable (const/let/var at module level)
+                    const varDecl = moduleLocalVariables.get(identifierName)
+                    if (varDecl) {
+                        // Analyze the variable's initializer for dependencies
+                        const varDependencies = analyzeVariableDependencies(varDecl, sourceFile, importMap, assignmentMap, moduleLocalFunctions, moduleLocalVariables)
+
+                        if (varDependencies.isContained) {
+                            // Mark as module-local and add any import dependencies to ambientRefs
+                            ambientRefs[identifierName] = {
+                                type: 'module-local'
+                            }
+
+                            // Add import dependencies from the variable's initializer
+                            for (const [depName, depInfo] of varDependencies.importDependencies) {
+                                if (!ambientRefs[depName]) {
+                                    ambientRefs[depName] = {
+                                        type: 'import',
+                                        importSpecifier: depInfo.importSpecifier,
+                                        moduleUri: depInfo.moduleUri
+                                    }
+                                }
+                            }
+                            return
+                        }
+                    }
+
                     // This is a literal ambient reference
                     // Check if the ambient reference is provided
                     if (runtimeAmbientRefs && identifierName in runtimeAmbientRefs) {
@@ -1282,12 +1472,22 @@ function extractAndValidateAmbientReferences(
 ): Record<string, any> {
     // Build module-local functions map for checking
     const moduleLocalFunctions = new Map<string, ts.FunctionDeclaration>()
+    // Build module-local variables map for checking (const/let/var declarations at module level)
+    const moduleLocalVariables = new Map<string, ts.VariableDeclaration>()
 
-    // Collect top-level module functions
+    // Collect top-level module functions and variables
     for (const statement of sourceFile.statements) {
         if (ts.isFunctionDeclaration(statement) && statement.name) {
             moduleLocalFunctions.set(statement.name.text, statement)
         }
+        // Collect module-level variable declarations
+        if (ts.isVariableStatement(statement)) {
+            for (const decl of statement.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name)) {
+                    moduleLocalVariables.set(decl.name.text, decl)
+                }
+            }
+        }
     }
 
     const ambientRefs: Record<string, any> = {}
@@ -1381,6 +1581,10 @@ function extractAndValidateAmbientReferences(
         // Track function declarations
         if (ts.isFunctionDeclaration(node) && node.name && ts.isIdentifier(node.name)) {
             localIdentifiers.add(node.name.text)
+            // Also track parameters from nested function declarations
+            for (const param of node.parameters) {
+                extractBindingIdentifiers(param.name)
+            }
         }
 
         // Track named function expressions (e.g., function Counter() {})
@@ -1447,6 +1651,15 @@ function extractAndValidateAmbientReferences(
                 return
             }
 
+            // Skip if this is a capsule['#'] pattern - the capsule name reference
+            // These references are resolved at encapsulation time and replaced with the actual string value
+            if (parent && ts.isElementAccessExpression(parent) && parent.expression === node) {
+                const arg = parent.argumentExpression
+                if (arg && ts.isStringLiteral(arg) && arg.text === '#') {
+                    return
+                }
+            }
+
             // Check if we already added this reference
             if (ambientRefs[identifierName]) {
                 return
@@ -1500,6 +1713,32 @@ function extractAndValidateAmbientReferences(
                         }
                     }
 
+                    // Check if it's a module-local variable (const/let/var at module level)
+                    const varDecl = moduleLocalVariables.get(identifierName)
+                    if (varDecl) {
+                        // Analyze the variable's initializer for dependencies
+                        const varDependencies = analyzeVariableDependencies(varDecl, sourceFile, importMap, assignmentMap, moduleLocalFunctions, moduleLocalVariables)
+
+                        if (varDependencies.isContained) {
+                            // Mark as module-local and add any import dependencies to ambientRefs
+                            ambientRefs[identifierName] = {
+                                type: 'module-local'
+                            }
+
+                            // Add import dependencies from the variable's initializer
+                            for (const [depName, depInfo] of varDependencies.importDependencies) {
+                                if (!ambientRefs[depName]) {
+                                    ambientRefs[depName] = {
+                                        type: 'import',
+                                        importSpecifier: depInfo.importSpecifier,
+                                        moduleUri: depInfo.moduleUri
+                                    }
+                                }
+                            }
+                            return
+                        }
+                    }
+
                     // Check if this is a JSX intrinsic element (like 'div', 'button', etc.) in a .tsx/.jsx file
                     const fileName = sourceFile.fileName
                     const isJsxFile = fileName.endsWith('.tsx') || fileName.endsWith('.jsx')