@grafema/core 0.1.1-alpha → 0.2.0-beta

package/src/core/nodes/EventListenerNode.ts

@@ -6,13 +6,13 @@ import type { BaseNodeRecord } from '@grafema/types';
 
 interface EventListenerNodeRecord extends BaseNodeRecord {
   type: 'EVENT_LISTENER';
+  column: number;
   object?: string;
   parentScopeId?: string;
   callbackArg?: string;
 }
 
 interface EventListenerNodeOptions {
-  column?: number;
   parentScopeId?: string;
   callbackArg?: string;
   counter?: number;
@@ -21,22 +21,24 @@ interface EventListenerNodeOptions {
 export class EventListenerNode {
   static readonly TYPE = 'EVENT_LISTENER' as const;
 
-  static readonly REQUIRED = ['name', 'file', 'line'] as const;
-  static readonly OPTIONAL = ['object', 'column', 'parentScopeId', 'callbackArg'] as const;
+  static readonly REQUIRED = ['name', 'file', 'line', 'column'] as const;
+  static readonly OPTIONAL = ['object', 'parentScopeId', 'callbackArg'] as const;
 
   static create(
     eventName: string,
     objectName: string | undefined,
     file: string,
     line: number,
+    column: number,
     options: EventListenerNodeOptions = {}
   ): EventListenerNodeRecord {
     if (!eventName) throw new Error('EventListenerNode.create: eventName is required');
     if (!file) throw new Error('EventListenerNode.create: file is required');
     if (line === undefined) throw new Error('EventListenerNode.create: line is required');
+    if (column === undefined) throw new Error('EventListenerNode.create: column is required');
 
     const counter = options.counter !== undefined ? `:${options.counter}` : '';
-    const id = `${file}:EVENT_LISTENER:${eventName}:${line}:${options.column || 0}${counter}`;
+    const id = `${file}:EVENT_LISTENER:${eventName}:${line}:${column}${counter}`;
 
     return {
       id,
@@ -45,6 +47,7 @@ export class EventListenerNode {
       object: objectName,
       file,
       line,
+      column,
       parentScopeId: options.parentScopeId,
       callbackArg: options.callbackArg
     };

package/src/core/nodes/ExportNode.ts

@@ -48,8 +48,8 @@ interface ExportContextOptions {
 export class ExportNode {
   static readonly TYPE = 'EXPORT' as const;
 
-  static readonly REQUIRED = ['name', 'file', 'line'] as const;
-  static readonly OPTIONAL = ['column', 'exportKind', 'local', 'default', 'source', 'exportType'] as const;
+  static readonly REQUIRED = ['name', 'file', 'line', 'column'] as const;
+  static readonly OPTIONAL = ['exportKind', 'local', 'default', 'source', 'exportType'] as const;
 
   static create(
     name: string,
@@ -61,6 +61,7 @@ export class ExportNode {
     if (!name) throw new Error('ExportNode.create: name is required');
     if (!file) throw new Error('ExportNode.create: file is required');
     if (!line) throw new Error('ExportNode.create: line is required');
+    if (column === undefined) throw new Error('ExportNode.create: column is required');
 
     return {
       id: `${file}:EXPORT:${name}:${line}`,
@@ -68,7 +69,7 @@ export class ExportNode {
       name,
       file,
       line,
-      column: column || 0,
+      column,
       exportKind: options.exportKind || 'value',
       local: options.local || name,
       default: options.default || false,
@@ -99,6 +100,7 @@ export class ExportNode {
     if (!name) throw new Error('ExportNode.createWithContext: name is required');
     if (!context.file) throw new Error('ExportNode.createWithContext: file is required');
     if (location.line === undefined) throw new Error('ExportNode.createWithContext: line is required');
+    if (location.column === undefined) throw new Error('ExportNode.createWithContext: column is required');
 
     // Compute semantic ID
     const id = computeSemanticId(this.TYPE, name, context);
@@ -109,7 +111,7 @@ export class ExportNode {
       name,
       file: context.file,
       line: location.line,
-      column: location.column ?? 0,
+      column: location.column,
       exportKind: options.exportKind || 'value',
       local: options.local || name,
       default: options.default || false,

package/src/core/nodes/ExpressionNode.ts

@@ -46,9 +46,9 @@ interface ExpressionNodeOptions {
 export class ExpressionNode {
   static readonly TYPE = 'EXPRESSION' as const;
 
-  static readonly REQUIRED = ['expressionType', 'file', 'line'] as const;
+  static readonly REQUIRED = ['expressionType', 'file', 'line', 'column'] as const;
   static readonly OPTIONAL = [
-    'column', 'object', 'property', 'computed', 'computedPropertyVar',
+    'object', 'property', 'computed', 'computedPropertyVar',
     'operator', 'path', 'baseName', 'propertyPath', 'arrayIndex'
   ] as const;
 
@@ -72,6 +72,7 @@ export class ExpressionNode {
     if (!expressionType) throw new Error('ExpressionNode.create: expressionType is required');
     if (!file) throw new Error('ExpressionNode.create: file is required');
     if (!line) throw new Error('ExpressionNode.create: line is required');
+    if (column === undefined) throw new Error('ExpressionNode.create: column is required');
 
     const node: ExpressionNodeRecord = {
       id: `${file}:EXPRESSION:${expressionType}:${line}:${column}`,
@@ -79,7 +80,7 @@ export class ExpressionNode {
       name: this._computeName(expressionType, options),
       file,
       line,
-      column: column || 0,
+      column,
       expressionType
     };
 
@@ -191,7 +192,7 @@ export class ExpressionNode {
       name: this._computeName(expressionType, options),
       file,
       line,
-      column: column || 0,
+      column,
       expressionType
     };
 

package/src/core/nodes/ExternalModuleNode.ts

@@ -23,16 +23,25 @@ export class ExternalModuleNode {
   /**
    * Create EXTERNAL_MODULE node
    *
+   * Normalizes node: prefix for Node.js builtins:
+   * - 'node:fs' -> 'fs'
+   * - 'node:path' -> 'path'
+   *
    * @param source - Module name (e.g., 'lodash', '@tanstack/react-query', 'node:fs')
    * @returns ExternalModuleNodeRecord
    */
   static create(source: string): ExternalModuleNodeRecord {
     if (!source) throw new Error('ExternalModuleNode.create: source is required');
 
+    // Normalize node: prefix for Node.js builtins
+    const normalizedSource = source.startsWith('node:')
+      ? source.slice(5)
+      : source;
+
     return {
-      id: `EXTERNAL_MODULE:${source}`,
+      id: `EXTERNAL_MODULE:${normalizedSource}`,
       type: this.TYPE,
-      name: source,
+      name: normalizedSource,
       file: '',
       line: 0
     };

package/src/core/nodes/HttpRequestNode.ts

@@ -6,13 +6,13 @@ import type { BaseNodeRecord } from '@grafema/types';
 
 interface HttpRequestNodeRecord extends BaseNodeRecord {
   type: 'HTTP_REQUEST';
+  column: number;
   url?: string;
   method: string;
   parentScopeId?: string;
 }
 
 interface HttpRequestNodeOptions {
-  column?: number;
   parentScopeId?: string;
   counter?: number;
 }
@@ -20,22 +20,24 @@ interface HttpRequestNodeOptions {
 export class HttpRequestNode {
   static readonly TYPE = 'HTTP_REQUEST' as const;
 
-  static readonly REQUIRED = ['name', 'file', 'line'] as const;
-  static readonly OPTIONAL = ['url', 'method', 'column', 'parentScopeId'] as const;
+  static readonly REQUIRED = ['name', 'file', 'line', 'column'] as const;
+  static readonly OPTIONAL = ['url', 'method', 'parentScopeId'] as const;
 
   static create(
     url: string | undefined,
     method: string | undefined,
     file: string,
     line: number,
+    column: number,
     options: HttpRequestNodeOptions = {}
   ): HttpRequestNodeRecord {
     if (!file) throw new Error('HttpRequestNode.create: file is required');
     if (line === undefined) throw new Error('HttpRequestNode.create: line is required');
+    if (column === undefined) throw new Error('HttpRequestNode.create: column is required');
 
     const httpMethod = method || 'GET';
     const counter = options.counter !== undefined ? `:${options.counter}` : '';
-    const id = `${file}:HTTP_REQUEST:${httpMethod}:${line}:${options.column || 0}${counter}`;
+    const id = `${file}:HTTP_REQUEST:${httpMethod}:${line}:${column}${counter}`;
 
     return {
       id,
@@ -45,6 +47,7 @@ export class HttpRequestNode {
       method: httpMethod,
       file,
       line,
+      column,
       parentScopeId: options.parentScopeId
     };
   }

package/src/core/nodes/ImportNode.ts

@@ -15,6 +15,10 @@ interface ImportNodeRecord extends BaseNodeRecord {
   importBinding: ImportBinding; // RENAMED: WHAT is imported (semantics)
   imported: string;
   local: string;
+  isDynamic?: boolean;         // true for dynamic import() expressions
+  isResolvable?: boolean;      // true if path is a string literal (statically analyzable)
+  dynamicPath?: string;        // original expression for template/variable paths
+  sideEffect?: boolean;        // REG-273: true for side-effect-only imports
 }
 
 interface ImportNodeOptions {
@@ -22,13 +26,17 @@ interface ImportNodeOptions {
   importBinding?: ImportBinding;
   imported?: string;            // Used for auto-detection if importType not provided
   local?: string;
+  isDynamic?: boolean;          // true for dynamic import() expressions
+  isResolvable?: boolean;       // true if path is a string literal (statically analyzable)
+  dynamicPath?: string;         // original expression for template/variable paths
+  sideEffect?: boolean;         // REG-273: true for side-effect-only imports
 }
 
 export class ImportNode {
   static readonly TYPE = 'IMPORT' as const;
 
-  static readonly REQUIRED = ['name', 'file', 'line', 'source'] as const;
-  static readonly OPTIONAL = ['column', 'importType', 'importBinding', 'imported', 'local'] as const;
+  static readonly REQUIRED = ['name', 'file', 'line', 'column', 'source'] as const;
+  static readonly OPTIONAL = ['importType', 'importBinding', 'imported', 'local', 'isDynamic', 'isResolvable', 'dynamicPath', 'sideEffect'] as const;
 
   /**
    * Create IMPORT node
@@ -52,6 +60,7 @@ export class ImportNode {
     if (!name) throw new Error('ImportNode.create: name is required');
     if (!file) throw new Error('ImportNode.create: file is required');
     if (line === undefined) throw new Error('ImportNode.create: line is required');
+    if (column === undefined) throw new Error('ImportNode.create: column is required');
     if (!source) throw new Error('ImportNode.create: source is required');
 
     // Auto-detect importType from imported field if not explicitly provided
@@ -61,19 +70,37 @@ export class ImportNode {
                    options.imported === '*' ? 'namespace' : 'named';
     }
 
-    return {
+    const record: ImportNodeRecord = {
       id: `${file}:IMPORT:${source}:${name}`,  // SEMANTIC ID: no line number
       type: this.TYPE,
       name,
       file,
       line,      // Stored as field, not in ID
-      column: column || 0,
+      column,
       source,
       importType: importType || 'named',           // NEW field with auto-detection
       importBinding: options.importBinding || 'value',  // RENAMED field
       imported: options.imported || name,
       local: options.local || name
     };
+
+    // Add dynamic import fields if provided
+    if (options.isDynamic !== undefined) {
+      record.isDynamic = options.isDynamic;
+    }
+    if (options.isResolvable !== undefined) {
+      record.isResolvable = options.isResolvable;
+    }
+    if (options.dynamicPath !== undefined) {
+      record.dynamicPath = options.dynamicPath;
+    }
+
+    // REG-273: Add sideEffect field if provided
+    if (options.sideEffect !== undefined) {
+      record.sideEffect = options.sideEffect;
+    }
+
+    return record;
   }
 
   static validate(node: ImportNodeRecord): string[] {

package/src/core/nodes/InterfaceNode.ts

@@ -33,8 +33,8 @@ interface InterfaceNodeOptions {
 export class InterfaceNode {
   static readonly TYPE = 'INTERFACE' as const;
 
-  static readonly REQUIRED = ['name', 'file', 'line'] as const;
-  static readonly OPTIONAL = ['column', 'extends', 'properties', 'isExternal'] as const;
+  static readonly REQUIRED = ['name', 'file', 'line', 'column'] as const;
+  static readonly OPTIONAL = ['extends', 'properties', 'isExternal'] as const;
 
   /**
    * Create INTERFACE node
@@ -56,6 +56,7 @@ export class InterfaceNode {
     if (!name) throw new Error('InterfaceNode.create: name is required');
     if (!file) throw new Error('InterfaceNode.create: file is required');
     if (!line) throw new Error('InterfaceNode.create: line is required');
+    if (column === undefined) throw new Error('InterfaceNode.create: column is required');
 
     return {
       id: `${file}:INTERFACE:${name}:${line}`,
@@ -63,7 +64,7 @@ export class InterfaceNode {
       name,
       file,
       line,
-      column: column || 0,
+      column,
       extends: options.extends || [],
       properties: options.properties || [],
       ...(options.isExternal !== undefined && { isExternal: options.isExternal })

package/src/core/nodes/LiteralNode.ts

@@ -22,8 +22,8 @@ interface LiteralNodeOptions {
 export class LiteralNode {
   static readonly TYPE = 'LITERAL' as const;
 
-  static readonly REQUIRED = ['file', 'line'] as const;
-  static readonly OPTIONAL = ['value', 'valueType', 'column', 'parentCallId', 'argIndex'] as const;
+  static readonly REQUIRED = ['file', 'line', 'column'] as const;
+  static readonly OPTIONAL = ['value', 'valueType', 'parentCallId', 'argIndex'] as const;
 
   static create(
     value: unknown,
@@ -34,10 +34,11 @@ export class LiteralNode {
   ): LiteralNodeRecord {
     if (!file) throw new Error('LiteralNode.create: file is required');
     if (line === undefined) throw new Error('LiteralNode.create: line is required');
+    if (column === undefined) throw new Error('LiteralNode.create: column is required');
 
     const counter = options.counter !== undefined ? `:${options.counter}` : '';
     const argIndex = options.argIndex !== undefined ? `arg${options.argIndex}` : 'value';
-    const id = `${file}:LITERAL:${argIndex}:${line}:${column || 0}${counter}`;
+    const id = `${file}:LITERAL:${argIndex}:${line}:${column}${counter}`;
 
     return {
       id,
@@ -47,7 +48,7 @@ export class LiteralNode {
       valueType: typeof value,
       file,
       line,
-      column: column || 0,
+      column,
       parentCallId: options.parentCallId,
       argIndex: options.argIndex
     };

package/src/core/nodes/MethodCallNode.ts

@@ -39,8 +39,8 @@ interface MethodCallContextOptions {
 export class MethodCallNode {
   static readonly TYPE = 'METHOD_CALL' as const;
 
-  static readonly REQUIRED = ['name', 'file', 'line', 'args'] as const;
-  static readonly OPTIONAL = ['object', 'method', 'column', 'parentScopeId'] as const;
+  static readonly REQUIRED = ['name', 'file', 'line', 'column', 'args'] as const;
+  static readonly OPTIONAL = ['object', 'method', 'parentScopeId'] as const;
 
   /**
    * Create METHOD_CALL node
@@ -56,10 +56,11 @@ export class MethodCallNode {
     if (!methodName) throw new Error('MethodCallNode.create: methodName is required');
     if (!file) throw new Error('MethodCallNode.create: file is required');
     if (line === undefined) throw new Error('MethodCallNode.create: line is required');
+    if (column === undefined) throw new Error('MethodCallNode.create: column is required');
 
     const fullName = objectName ? `${objectName}.${methodName}` : methodName;
     const counter = options.counter !== undefined ? `:${options.counter}` : '';
-    const id = `${file}:METHOD_CALL:${fullName}:${line}:${column || 0}${counter}`;
+    const id = `${file}:METHOD_CALL:${fullName}:${line}:${column}${counter}`;
 
     return {
       id,
@@ -69,7 +70,7 @@ export class MethodCallNode {
       method: methodName,
       file,
       line,
-      column: column || 0,
+      column,
       parentScopeId: options.parentScopeId,
       args: options.args || []
     };
@@ -99,6 +100,7 @@ export class MethodCallNode {
     if (!methodName) throw new Error('MethodCallNode.createWithContext: methodName is required');
     if (!context.file) throw new Error('MethodCallNode.createWithContext: file is required');
     if (location.line === undefined) throw new Error('MethodCallNode.createWithContext: line is required');
+    if (location.column === undefined) throw new Error('MethodCallNode.createWithContext: column is required');
     if (options.discriminator === undefined) throw new Error('MethodCallNode.createWithContext: discriminator is required');
 
     const fullName = objectName ? `${objectName}.${methodName}` : methodName;
@@ -116,7 +118,7 @@ export class MethodCallNode {
       method: methodName,
       file: context.file,
       line: location.line,
-      column: location.column ?? 0,
+      column: location.column,
       parentScopeId: options.parentScopeId,
       args: options.args || []
     };

package/src/core/nodes/MethodNode.ts

@@ -44,8 +44,8 @@ interface MethodContextOptions {
 export class MethodNode {
   static readonly TYPE = 'METHOD' as const;
 
-  static readonly REQUIRED = ['name', 'file', 'line', 'className'] as const;
-  static readonly OPTIONAL = ['column', 'async', 'generator', 'static', 'kind'] as const;
+  static readonly REQUIRED = ['name', 'file', 'line', 'column', 'className'] as const;
+  static readonly OPTIONAL = ['async', 'generator', 'static', 'kind'] as const;
 
   static create(
     name: string,
@@ -58,6 +58,7 @@ export class MethodNode {
     if (!name) throw new Error('MethodNode.create: name is required');
     if (!file) throw new Error('MethodNode.create: file is required');
     if (!line) throw new Error('MethodNode.create: line is required');
+    if (column === undefined) throw new Error('MethodNode.create: column is required');
     if (!className) throw new Error('MethodNode.create: className is required');
 
     return {
@@ -66,7 +67,7 @@ export class MethodNode {
       name,
       file,
       line,
-      column: column || 0,
+      column,
       className,
       async: options.async || false,
       generator: options.generator || false,
@@ -101,6 +102,7 @@ export class MethodNode {
     if (!className) throw new Error('MethodNode.createWithContext: className is required');
     if (!context.file) throw new Error('MethodNode.createWithContext: file is required');
     if (location.line === undefined) throw new Error('MethodNode.createWithContext: line is required');
+    if (location.column === undefined) throw new Error('MethodNode.createWithContext: column is required');
 
     // Compute semantic ID
     const id = computeSemanticId(this.TYPE, name, context);
@@ -111,7 +113,7 @@ export class MethodNode {
       name,
       file: context.file,
       line: location.line,
-      column: location.column ?? 0,
+      column: location.column,
       className,
       async: options.async || false,
       generator: options.generator || false,

package/src/core/nodes/ObjectLiteralNode.ts

@@ -34,10 +34,11 @@ export class ObjectLiteralNode {
   ): ObjectLiteralNodeRecord {
     if (!file) throw new Error('ObjectLiteralNode.create: file is required');
     if (line === undefined) throw new Error('ObjectLiteralNode.create: line is required');
+    if (column === undefined) throw new Error('ObjectLiteralNode.create: column is required');
 
     const counter = options.counter !== undefined ? `:${options.counter}` : '';
     const argSuffix = options.argIndex !== undefined ? `arg${options.argIndex}` : 'obj';
-    const id = `OBJECT_LITERAL#${argSuffix}#${file}#${line}:${column || 0}${counter}`;
+    const id = `OBJECT_LITERAL#${argSuffix}#${file}#${line}:${column}${counter}`;
 
     return {
       id,
@@ -45,7 +46,7 @@ export class ObjectLiteralNode {
       name: `<object>`,
       file,
       line,
-      column: column || 0,
+      column,
       parentCallId: options.parentCallId,
       argIndex: options.argIndex
     };

package/src/core/nodes/ParameterNode.ts

@@ -22,8 +22,8 @@ interface ParameterNodeOptions {
 export class ParameterNode {
   static readonly TYPE = 'PARAMETER' as const;
 
-  static readonly REQUIRED = ['name', 'file', 'line', 'functionId'] as const;
-  static readonly OPTIONAL = ['column', 'index', 'defaultValue', 'rest'] as const;
+  static readonly REQUIRED = ['name', 'file', 'line', 'column', 'functionId'] as const;
+  static readonly OPTIONAL = ['index', 'defaultValue', 'rest'] as const;
 
   static create(
     name: string,
@@ -36,6 +36,7 @@ export class ParameterNode {
     if (!name) throw new Error('ParameterNode.create: name is required');
     if (!file) throw new Error('ParameterNode.create: file is required');
     if (!line) throw new Error('ParameterNode.create: line is required');
+    if (column === undefined) throw new Error('ParameterNode.create: column is required');
     if (!functionId) throw new Error('ParameterNode.create: functionId is required');
 
     return {
@@ -44,7 +45,7 @@ export class ParameterNode {
       name,
       file,
       line,
-      column: column || 0,
+      column,
       functionId,
       index: options.index || 0,
       defaultValue: options.defaultValue,

package/src/core/nodes/TypeNode.ts

@@ -22,8 +22,8 @@ interface TypeNodeOptions {
 export class TypeNode {
   static readonly TYPE = 'TYPE' as const;
 
-  static readonly REQUIRED = ['name', 'file', 'line'] as const;
-  static readonly OPTIONAL = ['column', 'aliasOf'] as const;
+  static readonly REQUIRED = ['name', 'file', 'line', 'column'] as const;
+  static readonly OPTIONAL = ['aliasOf'] as const;
 
   /**
    * Create TYPE node
@@ -45,6 +45,7 @@ export class TypeNode {
     if (!name) throw new Error('TypeNode.create: name is required');
     if (!file) throw new Error('TypeNode.create: file is required');
     if (!line) throw new Error('TypeNode.create: line is required');
+    if (column === undefined) throw new Error('TypeNode.create: column is required');
 
     return {
       id: `${file}:TYPE:${name}:${line}`,
@@ -52,7 +53,7 @@ export class TypeNode {
       name,
       file,
       line,
-      column: column || 0,
+      column,
       aliasOf: options.aliasOf
     };
   }

package/src/core/nodes/VariableDeclarationNode.ts

@@ -33,8 +33,8 @@ interface VariableContextOptions {
 export class VariableDeclarationNode {
   static readonly TYPE = 'VARIABLE_DECLARATION' as const;
 
-  static readonly REQUIRED = ['name', 'file', 'line'] as const;
-  static readonly OPTIONAL = ['column', 'parentScopeId'] as const;
+  static readonly REQUIRED = ['name', 'file', 'line', 'column'] as const;
+  static readonly OPTIONAL = ['parentScopeId'] as const;
 
   static create(
     name: string,
@@ -46,9 +46,10 @@ export class VariableDeclarationNode {
     if (!name) throw new Error('VariableDeclarationNode.create: name is required');
     if (!file) throw new Error('VariableDeclarationNode.create: file is required');
     if (line === undefined) throw new Error('VariableDeclarationNode.create: line is required');
+    if (column === undefined) throw new Error('VariableDeclarationNode.create: column is required');
 
     const counter = options.counter !== undefined ? `:${options.counter}` : '';
-    const id = `${file}:VARIABLE_DECLARATION:${name}:${line}:${column || 0}${counter}`;
+    const id = `${file}:VARIABLE_DECLARATION:${name}:${line}:${column}${counter}`;
 
     return {
       id,
@@ -56,7 +57,7 @@ export class VariableDeclarationNode {
       name,
       file,
       line,
-      column: column || 0,
+      column,
       parentScopeId: options.parentScopeId
     };
   }
@@ -83,6 +84,7 @@ export class VariableDeclarationNode {
     if (!name) throw new Error('VariableDeclarationNode.createWithContext: name is required');
     if (!context.file) throw new Error('VariableDeclarationNode.createWithContext: file is required');
     if (location.line === undefined) throw new Error('VariableDeclarationNode.createWithContext: line is required');
+    if (location.column === undefined) throw new Error('VariableDeclarationNode.createWithContext: column is required');
 
     // Compute semantic ID using 'VARIABLE' type for cleaner IDs
     const id = computeSemanticId('VARIABLE', name, context);
@@ -93,7 +95,7 @@ export class VariableDeclarationNode {
       name,
       file: context.file,
       line: location.line,
-      column: location.column ?? 0,
+      column: location.column,
       parentScopeId: options.parentScopeId
     };
   }

package/src/core/nodes/index.ts

@@ -11,10 +11,13 @@ export { ClassNode, type ClassNodeRecord } from './ClassNode.js';
 export { MethodNode, type MethodNodeRecord, type MethodKind } from './MethodNode.js';
 export { ParameterNode, type ParameterNodeRecord } from './ParameterNode.js';
 export { ScopeNode, type ScopeNodeRecord } from './ScopeNode.js';
+export { BranchNode, type BranchNodeRecord } from './BranchNode.js';
+export { CaseNode, type CaseNodeRecord } from './CaseNode.js';
 
 // Call/reference nodes
 export { CallSiteNode, type CallSiteNodeRecord } from './CallSiteNode.js';
 export { MethodCallNode, type MethodCallNodeRecord } from './MethodCallNode.js';
+export { ConstructorCallNode, type ConstructorCallNodeRecord } from './ConstructorCallNode.js';
 export { VariableDeclarationNode, type VariableDeclarationNodeRecord } from './VariableDeclarationNode.js';
 export { ConstantNode, type ConstantNodeRecord } from './ConstantNode.js';
 export { LiteralNode, type LiteralNodeRecord } from './LiteralNode.js';