@grafema/core 0.1.1-alpha → 0.2.0-beta

package/dist/data/builtins/BuiltinRegistry.d.ts

@@ -0,0 +1,78 @@
+/**
+ * BuiltinRegistry - Registry for Node.js builtin functions (REG-218)
+ *
+ * Provides lookup for Node.js builtin modules and functions.
+ * Used by NodejsBuiltinsResolver for lazy EXTERNAL_FUNCTION node creation.
+ *
+ * Usage:
+ *   const registry = new BuiltinRegistry();
+ *   if (registry.isBuiltinModule('fs')) {
+ *     const funcDef = registry.getFunction('fs', 'readFile');
+ *     if (funcDef) {
+ *       // Create EXTERNAL_FUNCTION node with metadata
+ *     }
+ *   }
+ */
+import type { BuiltinFunctionDef, BuiltinModuleDef } from './types.js';
+export declare class BuiltinRegistry {
+    /** Map of module name to module definition */
+    private modules;
+    /** Map of "module:funcName" to function definition for fast lookup */
+    private functions;
+    constructor(modules?: BuiltinModuleDef[]);
+    /**
+     * Check if module is a Node.js builtin module.
+     * Handles node: prefix automatically.
+     *
+     * @param moduleName - Module name (e.g., 'fs', 'node:fs', 'fs/promises')
+     * @returns true if module is a known builtin
+     */
+    isBuiltinModule(moduleName: string): boolean;
+    /**
+     * Normalize module name by stripping node: prefix.
+     *
+     * @param moduleName - Module name (e.g., 'node:fs', 'fs')
+     * @returns Normalized module name (e.g., 'fs')
+     */
+    normalizeModule(moduleName: string): string;
+    /**
+     * Get function definition by module and function name.
+     *
+     * @param module - Module name (e.g., 'fs', 'node:fs')
+     * @param funcName - Function name (e.g., 'readFile')
+     * @returns Function definition or null if not found
+     */
+    getFunction(module: string, funcName: string): BuiltinFunctionDef | null;
+    /**
+     * Check if function is a known builtin function.
+     *
+     * @param module - Module name
+     * @param funcName - Function name
+     * @returns true if function is known
+     */
+    isKnownFunction(module: string, funcName: string): boolean;
+    /**
+     * Get all functions for a module.
+     *
+     * @param module - Module name
+     * @returns Array of function definitions (empty if module not found)
+     */
+    getAllFunctions(module: string): BuiltinFunctionDef[];
+    /**
+     * List all supported builtin module names.
+     *
+     * @returns Array of module names
+     */
+    listModules(): string[];
+    /**
+     * Create node ID for EXTERNAL_FUNCTION node.
+     *
+     * Format: EXTERNAL_FUNCTION:{module}.{funcName}
+     *
+     * @param module - Module name (will be normalized)
+     * @param funcName - Function name
+     * @returns Node ID string
+     */
+    createNodeId(module: string, funcName: string): string;
+}
+//# sourceMappingURL=BuiltinRegistry.d.ts.map

package/dist/data/builtins/BuiltinRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BuiltinRegistry.d.ts","sourceRoot":"","sources":["../../../src/data/builtins/BuiltinRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGvE,qBAAa,eAAe;IAC1B,8CAA8C;IAC9C,OAAO,CAAC,OAAO,CAAgC;IAE/C,sEAAsE;IACtE,OAAO,CAAC,SAAS,CAAkC;gBAEvC,OAAO,GAAE,gBAAgB,EAAwB;IAc7D;;;;;;OAMG;IACH,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAK5C;;;;;OAKG;IACH,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAO3C;;;;;;OAMG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI;IAMxE;;;;;;OAMG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI1D;;;;;OAKG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,EAAE;IAMrD;;;;OAIG;IACH,WAAW,IAAI,MAAM,EAAE;IAIvB;;;;;;;;OAQG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;CAIvD"}

package/dist/data/builtins/BuiltinRegistry.js

@@ -0,0 +1,110 @@
+/**
+ * BuiltinRegistry - Registry for Node.js builtin functions (REG-218)
+ *
+ * Provides lookup for Node.js builtin modules and functions.
+ * Used by NodejsBuiltinsResolver for lazy EXTERNAL_FUNCTION node creation.
+ *
+ * Usage:
+ *   const registry = new BuiltinRegistry();
+ *   if (registry.isBuiltinModule('fs')) {
+ *     const funcDef = registry.getFunction('fs', 'readFile');
+ *     if (funcDef) {
+ *       // Create EXTERNAL_FUNCTION node with metadata
+ *     }
+ *   }
+ */
+import { ALL_BUILTIN_MODULES } from './definitions.js';
+export class BuiltinRegistry {
+    /** Map of module name to module definition */
+    modules;
+    /** Map of "module:funcName" to function definition for fast lookup */
+    functions;
+    constructor(modules = ALL_BUILTIN_MODULES) {
+        this.modules = new Map();
+        this.functions = new Map();
+        for (const mod of modules) {
+            this.modules.set(mod.name, mod);
+            for (const func of mod.functions) {
+                const key = `${mod.name}:${func.name}`;
+                this.functions.set(key, func);
+            }
+        }
+    }
+    /**
+     * Check if module is a Node.js builtin module.
+     * Handles node: prefix automatically.
+     *
+     * @param moduleName - Module name (e.g., 'fs', 'node:fs', 'fs/promises')
+     * @returns true if module is a known builtin
+     */
+    isBuiltinModule(moduleName) {
+        const normalized = this.normalizeModule(moduleName);
+        return this.modules.has(normalized);
+    }
+    /**
+     * Normalize module name by stripping node: prefix.
+     *
+     * @param moduleName - Module name (e.g., 'node:fs', 'fs')
+     * @returns Normalized module name (e.g., 'fs')
+     */
+    normalizeModule(moduleName) {
+        if (moduleName.startsWith('node:')) {
+            return moduleName.slice(5); // Remove 'node:' prefix
+        }
+        return moduleName;
+    }
+    /**
+     * Get function definition by module and function name.
+     *
+     * @param module - Module name (e.g., 'fs', 'node:fs')
+     * @param funcName - Function name (e.g., 'readFile')
+     * @returns Function definition or null if not found
+     */
+    getFunction(module, funcName) {
+        const normalizedModule = this.normalizeModule(module);
+        const key = `${normalizedModule}:${funcName}`;
+        return this.functions.get(key) || null;
+    }
+    /**
+     * Check if function is a known builtin function.
+     *
+     * @param module - Module name
+     * @param funcName - Function name
+     * @returns true if function is known
+     */
+    isKnownFunction(module, funcName) {
+        return this.getFunction(module, funcName) !== null;
+    }
+    /**
+     * Get all functions for a module.
+     *
+     * @param module - Module name
+     * @returns Array of function definitions (empty if module not found)
+     */
+    getAllFunctions(module) {
+        const normalizedModule = this.normalizeModule(module);
+        const mod = this.modules.get(normalizedModule);
+        return mod ? mod.functions : [];
+    }
+    /**
+     * List all supported builtin module names.
+     *
+     * @returns Array of module names
+     */
+    listModules() {
+        return Array.from(this.modules.keys());
+    }
+    /**
+     * Create node ID for EXTERNAL_FUNCTION node.
+     *
+     * Format: EXTERNAL_FUNCTION:{module}.{funcName}
+     *
+     * @param module - Module name (will be normalized)
+     * @param funcName - Function name
+     * @returns Node ID string
+     */
+    createNodeId(module, funcName) {
+        const normalizedModule = this.normalizeModule(module);
+        return `EXTERNAL_FUNCTION:${normalizedModule}.${funcName}`;
+    }
+}

package/dist/data/builtins/definitions.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Node.js Builtin Definitions (REG-218)
+ *
+ * Tier 1 builtin module definitions:
+ * - fs (filesystem)
+ * - fs/promises (async filesystem)
+ * - path (path manipulation)
+ * - http/https (network)
+ * - crypto (cryptography)
+ * - child_process (process execution)
+ *
+ * Additional modules (Tier 2):
+ * - url, util, os, events, stream, buffer, worker_threads
+ */
+import type { BuiltinModuleDef } from './types.js';
+/**
+ * Tier 1: Core Node.js modules (most commonly used)
+ */
+export declare const TIER_1_MODULES: BuiltinModuleDef[];
+/**
+ * Tier 2: Additional commonly used modules
+ */
+export declare const TIER_2_MODULES: BuiltinModuleDef[];
+/**
+ * All builtin modules combined
+ */
+export declare const ALL_BUILTIN_MODULES: BuiltinModuleDef[];
+//# sourceMappingURL=definitions.d.ts.map

package/dist/data/builtins/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../../src/data/builtins/definitions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,gBAAgB,EAgJ5C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,gBAAgB,EAyF5C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,gBAAgB,EAGjD,CAAC"}

package/dist/data/builtins/definitions.js

@@ -0,0 +1,250 @@
+/**
+ * Node.js Builtin Definitions (REG-218)
+ *
+ * Tier 1 builtin module definitions:
+ * - fs (filesystem)
+ * - fs/promises (async filesystem)
+ * - path (path manipulation)
+ * - http/https (network)
+ * - crypto (cryptography)
+ * - child_process (process execution)
+ *
+ * Additional modules (Tier 2):
+ * - url, util, os, events, stream, buffer, worker_threads
+ */
+/**
+ * Tier 1: Core Node.js modules (most commonly used)
+ */
+export const TIER_1_MODULES = [
+    // fs - Filesystem operations
+    {
+        name: 'fs',
+        functions: [
+            { name: 'readFile', module: 'fs', security: 'file-io', pure: false },
+            { name: 'readFileSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'writeFile', module: 'fs', security: 'file-io', pure: false },
+            { name: 'writeFileSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'appendFile', module: 'fs', security: 'file-io', pure: false },
+            { name: 'appendFileSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'readdir', module: 'fs', security: 'file-io', pure: false },
+            { name: 'readdirSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'mkdir', module: 'fs', security: 'file-io', pure: false },
+            { name: 'mkdirSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'rmdir', module: 'fs', security: 'file-io', pure: false },
+            { name: 'rmdirSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'rm', module: 'fs', security: 'file-io', pure: false },
+            { name: 'rmSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'unlink', module: 'fs', security: 'file-io', pure: false },
+            { name: 'unlinkSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'stat', module: 'fs', security: 'file-io', pure: false },
+            { name: 'statSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'lstat', module: 'fs', security: 'file-io', pure: false },
+            { name: 'lstatSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'access', module: 'fs', security: 'file-io', pure: false },
+            { name: 'accessSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'chmod', module: 'fs', security: 'file-io', pure: false },
+            { name: 'chmodSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'chown', module: 'fs', security: 'file-io', pure: false },
+            { name: 'chownSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'rename', module: 'fs', security: 'file-io', pure: false },
+            { name: 'renameSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'copyFile', module: 'fs', security: 'file-io', pure: false },
+            { name: 'copyFileSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'createReadStream', module: 'fs', security: 'file-io', pure: false },
+            { name: 'createWriteStream', module: 'fs', security: 'file-io', pure: false },
+            { name: 'watch', module: 'fs', security: 'file-io', pure: false },
+            { name: 'watchFile', module: 'fs', security: 'file-io', pure: false },
+            { name: 'existsSync', module: 'fs', security: 'file-io', pure: false },
+            { name: 'truncate', module: 'fs', security: 'file-io', pure: false },
+            { name: 'truncateSync', module: 'fs', security: 'file-io', pure: false },
+        ]
+    },
+    // fs/promises - Async filesystem operations
+    {
+        name: 'fs/promises',
+        functions: [
+            { name: 'readFile', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'writeFile', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'appendFile', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'readdir', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'mkdir', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'rmdir', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'rm', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'unlink', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'stat', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'lstat', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'access', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'chmod', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'chown', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'rename', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'copyFile', module: 'fs/promises', security: 'file-io', pure: false },
+            { name: 'truncate', module: 'fs/promises', security: 'file-io', pure: false },
+        ]
+    },
+    // path - Path manipulation (pure functions)
+    {
+        name: 'path',
+        functions: [
+            { name: 'join', module: 'path', pure: true },
+            { name: 'resolve', module: 'path', pure: true },
+            { name: 'normalize', module: 'path', pure: true },
+            { name: 'basename', module: 'path', pure: true },
+            { name: 'dirname', module: 'path', pure: true },
+            { name: 'extname', module: 'path', pure: true },
+            { name: 'parse', module: 'path', pure: true },
+            { name: 'format', module: 'path', pure: true },
+            { name: 'relative', module: 'path', pure: true },
+            { name: 'isAbsolute', module: 'path', pure: true },
+            { name: 'sep', module: 'path', pure: true },
+            { name: 'delimiter', module: 'path', pure: true },
+        ]
+    },
+    // http - HTTP server/client
+    {
+        name: 'http',
+        functions: [
+            { name: 'createServer', module: 'http', security: 'net', pure: false },
+            { name: 'request', module: 'http', security: 'net', pure: false },
+            { name: 'get', module: 'http', security: 'net', pure: false },
+        ]
+    },
+    // https - HTTPS server/client
+    {
+        name: 'https',
+        functions: [
+            { name: 'createServer', module: 'https', security: 'net', pure: false },
+            { name: 'request', module: 'https', security: 'net', pure: false },
+            { name: 'get', module: 'https', security: 'net', pure: false },
+        ]
+    },
+    // crypto - Cryptographic operations
+    {
+        name: 'crypto',
+        functions: [
+            { name: 'createHash', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'createHmac', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'createCipher', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'createDecipher', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'createCipheriv', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'createDecipheriv', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'randomBytes', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'randomFill', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'randomFillSync', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'randomUUID', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'pbkdf2', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'pbkdf2Sync', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'scrypt', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'scryptSync', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'generateKey', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'generateKeyPair', module: 'crypto', security: 'crypto', pure: false },
+            { name: 'generateKeyPairSync', module: 'crypto', security: 'crypto', pure: false },
+        ]
+    },
+    // child_process - Process execution (SECURITY SENSITIVE)
+    {
+        name: 'child_process',
+        functions: [
+            { name: 'exec', module: 'child_process', security: 'exec', pure: false },
+            { name: 'execSync', module: 'child_process', security: 'exec', pure: false },
+            { name: 'execFile', module: 'child_process', security: 'exec', pure: false },
+            { name: 'execFileSync', module: 'child_process', security: 'exec', pure: false },
+            { name: 'spawn', module: 'child_process', security: 'exec', pure: false },
+            { name: 'spawnSync', module: 'child_process', security: 'exec', pure: false },
+            { name: 'fork', module: 'child_process', security: 'exec', pure: false },
+        ]
+    },
+];
+/**
+ * Tier 2: Additional commonly used modules
+ */
+export const TIER_2_MODULES = [
+    // url - URL parsing
+    {
+        name: 'url',
+        functions: [
+            { name: 'parse', module: 'url', pure: true },
+            { name: 'format', module: 'url', pure: true },
+            { name: 'resolve', module: 'url', pure: true },
+            { name: 'fileURLToPath', module: 'url', pure: true },
+            { name: 'pathToFileURL', module: 'url', pure: true },
+        ]
+    },
+    // util - Utilities
+    {
+        name: 'util',
+        functions: [
+            { name: 'promisify', module: 'util', pure: true },
+            { name: 'callbackify', module: 'util', pure: true },
+            { name: 'inspect', module: 'util', pure: true },
+            { name: 'format', module: 'util', pure: true },
+            { name: 'deprecate', module: 'util', pure: false },
+            { name: 'inherits', module: 'util', pure: false },
+        ]
+    },
+    // os - Operating system info
+    {
+        name: 'os',
+        functions: [
+            { name: 'platform', module: 'os', pure: true },
+            { name: 'arch', module: 'os', pure: true },
+            { name: 'cpus', module: 'os', pure: false },
+            { name: 'hostname', module: 'os', pure: false },
+            { name: 'homedir', module: 'os', pure: false },
+            { name: 'tmpdir', module: 'os', pure: false },
+            { name: 'type', module: 'os', pure: true },
+            { name: 'release', module: 'os', pure: true },
+            { name: 'totalmem', module: 'os', pure: false },
+            { name: 'freemem', module: 'os', pure: false },
+        ]
+    },
+    // events - Event emitter
+    {
+        name: 'events',
+        functions: [
+            { name: 'EventEmitter', module: 'events', pure: false },
+            { name: 'once', module: 'events', pure: false },
+            { name: 'on', module: 'events', pure: false },
+        ]
+    },
+    // stream - Streams
+    {
+        name: 'stream',
+        functions: [
+            { name: 'Readable', module: 'stream', pure: false },
+            { name: 'Writable', module: 'stream', pure: false },
+            { name: 'Duplex', module: 'stream', pure: false },
+            { name: 'Transform', module: 'stream', pure: false },
+            { name: 'pipeline', module: 'stream', pure: false },
+            { name: 'finished', module: 'stream', pure: false },
+        ]
+    },
+    // buffer - Buffer operations
+    {
+        name: 'buffer',
+        functions: [
+            { name: 'Buffer', module: 'buffer', pure: false },
+            { name: 'alloc', module: 'buffer', pure: true },
+            { name: 'allocUnsafe', module: 'buffer', pure: true },
+            { name: 'from', module: 'buffer', pure: true },
+            { name: 'concat', module: 'buffer', pure: true },
+            { name: 'isBuffer', module: 'buffer', pure: true },
+        ]
+    },
+    // worker_threads - Worker threads
+    {
+        name: 'worker_threads',
+        functions: [
+            { name: 'Worker', module: 'worker_threads', pure: false },
+            { name: 'isMainThread', module: 'worker_threads', pure: true },
+            { name: 'parentPort', module: 'worker_threads', pure: false },
+            { name: 'workerData', module: 'worker_threads', pure: false },
+        ]
+    },
+];
+/**
+ * All builtin modules combined
+ */
+export const ALL_BUILTIN_MODULES = [
+    ...TIER_1_MODULES,
+    ...TIER_2_MODULES,
+];

package/dist/data/builtins/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Node.js Builtins Registry (REG-218)
+ *
+ * Exports for builtin function registry.
+ */
+export { BuiltinRegistry } from './BuiltinRegistry.js';
+export type { BuiltinFunctionDef, BuiltinModuleDef, SecurityCategory } from './types.js';
+export { ALL_BUILTIN_MODULES, TIER_1_MODULES, TIER_2_MODULES } from './definitions.js';
+export { JS_GLOBAL_FUNCTIONS } from './jsGlobals.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/data/builtins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/data/builtins/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,YAAY,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACzF,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvF,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/data/builtins/index.js

@@ -0,0 +1,8 @@
+/**
+ * Node.js Builtins Registry (REG-218)
+ *
+ * Exports for builtin function registry.
+ */
+export { BuiltinRegistry } from './BuiltinRegistry.js';
+export { ALL_BUILTIN_MODULES, TIER_1_MODULES, TIER_2_MODULES } from './definitions.js';
+export { JS_GLOBAL_FUNCTIONS } from './jsGlobals.js';

package/dist/data/builtins/jsGlobals.d.ts

@@ -0,0 +1,18 @@
+/**
+ * JavaScript Global Functions (REG-227)
+ *
+ * These are functions intrinsic to the JS runtime that don't need CALLS edges.
+ * They're available in all JS environments (browser, Node.js, etc.) and aren't
+ * "callable definitions" in the code sense.
+ *
+ * What is NOT included:
+ * - Constructors (Array, Object, Error) - handled as constructor calls
+ * - Objects with methods (Math, JSON) - method calls go through MethodCallResolver
+ * - Environment globals (window, document) - not functions, they're objects
+ *
+ * Used by:
+ * - ExternalCallResolver: skips these when resolving external calls
+ * - CallResolverValidator: recognizes these as resolved (no violation)
+ */
+export declare const JS_GLOBAL_FUNCTIONS: Set<string>;
+//# sourceMappingURL=jsGlobals.d.ts.map

package/dist/data/builtins/jsGlobals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsGlobals.d.ts","sourceRoot":"","sources":["../../../src/data/builtins/jsGlobals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,aAW9B,CAAC"}

package/dist/data/builtins/jsGlobals.js

@@ -0,0 +1,26 @@
+/**
+ * JavaScript Global Functions (REG-227)
+ *
+ * These are functions intrinsic to the JS runtime that don't need CALLS edges.
+ * They're available in all JS environments (browser, Node.js, etc.) and aren't
+ * "callable definitions" in the code sense.
+ *
+ * What is NOT included:
+ * - Constructors (Array, Object, Error) - handled as constructor calls
+ * - Objects with methods (Math, JSON) - method calls go through MethodCallResolver
+ * - Environment globals (window, document) - not functions, they're objects
+ *
+ * Used by:
+ * - ExternalCallResolver: skips these when resolving external calls
+ * - CallResolverValidator: recognizes these as resolved (no violation)
+ */
+export const JS_GLOBAL_FUNCTIONS = new Set([
+    // Global functions (truly called as standalone functions)
+    'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'eval',
+    'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent',
+    // Timers (global functions in browser & Node.js)
+    'setTimeout', 'setInterval', 'setImmediate',
+    'clearTimeout', 'clearInterval', 'clearImmediate',
+    // CommonJS (special case - global in CJS environments)
+    'require'
+]);

package/dist/data/builtins/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * BuiltinRegistry Types (REG-218)
+ *
+ * Type definitions for Node.js builtin function registry.
+ * Used for lazy EXTERNAL_FUNCTION node creation.
+ */
+/**
+ * Security category for builtin functions.
+ * Used for security analysis and auditing.
+ */
+export type SecurityCategory = 'file-io' | 'exec' | 'net' | 'crypto';
+/**
+ * Definition of a single builtin function.
+ */
+export interface BuiltinFunctionDef {
+    /** Function name (e.g., 'readFile') */
+    name: string;
+    /** Module name (e.g., 'fs', 'path', 'fs/promises') */
+    module: string;
+    /** Security category (for dangerous functions) */
+    security?: SecurityCategory;
+    /** Whether function is pure (no side effects) */
+    pure?: boolean;
+}
+/**
+ * Definition of a builtin module with its functions.
+ */
+export interface BuiltinModuleDef {
+    /** Module name (e.g., 'fs', 'path') */
+    name: string;
+    /** List of functions in this module */
+    functions: BuiltinFunctionDef[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/data/builtins/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/data/builtins/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,MAAM,EAAE,MAAM,CAAC;IACf,kDAAkD;IAClD,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,iDAAiD;IACjD,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,SAAS,EAAE,kBAAkB,EAAE,CAAC;CACjC"}

package/dist/data/builtins/types.js

@@ -0,0 +1,7 @@
+/**
+ * BuiltinRegistry Types (REG-218)
+ *
+ * Type definitions for Node.js builtin function registry.
+ * Used for lazy EXTERNAL_FUNCTION node creation.
+ */
+export {};

package/dist/data/globals/definitions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Global Symbol Definitions
+ *
+ * JavaScript/TypeScript globals that should not be reported as undefined.
+ * Organized by environment and category.
+ */
+/**
+ * ECMAScript standard globals (available in all JS environments)
+ */
+export declare const ECMASCRIPT_GLOBALS: string[];
+/**
+ * Node.js-specific globals
+ */
+export declare const NODEJS_GLOBALS: string[];
+/**
+ * Browser-specific globals (commonly used, may appear in isomorphic code)
+ */
+export declare const BROWSER_GLOBALS: string[];
+/**
+ * Test framework globals (common testing environments)
+ */
+export declare const TEST_GLOBALS: string[];
+/**
+ * All default globals combined
+ */
+export declare const ALL_GLOBALS: Set<string>;
+//# sourceMappingURL=definitions.d.ts.map

package/dist/data/globals/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../../src/data/globals/definitions.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,EAsCtC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,EAwClC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,EA8BnC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,EAYhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,GAAG,CAAC,MAAM,CAKlC,CAAC"}