@grafema/core 0.1.0-alpha.1

package/dist/core/nodes/MethodCallNode.d.ts

@@ -0,0 +1,29 @@
+/**
+ * MethodCallNode - contract for METHOD_CALL node
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+interface MethodCallNodeRecord extends BaseNodeRecord {
+    type: 'METHOD_CALL';
+    object?: string;
+    method: string;
+    column: number;
+    parentScopeId?: string;
+    args: unknown[];
+}
+interface MethodCallNodeOptions {
+    parentScopeId?: string;
+    args?: unknown[];
+    counter?: number;
+}
+export declare class MethodCallNode {
+    static readonly TYPE: "METHOD_CALL";
+    static readonly REQUIRED: readonly ["name", "file", "line", "args"];
+    static readonly OPTIONAL: readonly ["object", "method", "column", "parentScopeId"];
+    /**
+     * Create METHOD_CALL node
+     */
+    static create(objectName: string | undefined, methodName: string, file: string, line: number, column: number, options?: MethodCallNodeOptions): MethodCallNodeRecord;
+    static validate(node: MethodCallNodeRecord): string[];
+}
+export type { MethodCallNodeRecord };
+//# sourceMappingURL=MethodCallNode.d.ts.map

package/dist/core/nodes/MethodCallNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MethodCallNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/MethodCallNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,UAAU,oBAAqB,SAAQ,cAAc;IACnD,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB;AAED,UAAU,qBAAqB;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,cAAc;IACzB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,aAAa,CAAU;IAE9C,MAAM,CAAC,QAAQ,CAAC,QAAQ,4CAA6C;IACrE,MAAM,CAAC,QAAQ,CAAC,QAAQ,2DAA4D;IAEpF;;OAEG;IACH,MAAM,CAAC,MAAM,CACX,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,qBAA0B,GAClC,oBAAoB;IAuBvB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,GAAG,MAAM,EAAE;CAgBtD;AAED,YAAY,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/core/nodes/MethodCallNode.js

@@ -0,0 +1,47 @@
+/**
+ * MethodCallNode - contract for METHOD_CALL node
+ */
+export class MethodCallNode {
+    static TYPE = 'METHOD_CALL';
+    static REQUIRED = ['name', 'file', 'line', 'args'];
+    static OPTIONAL = ['object', 'method', 'column', 'parentScopeId'];
+    /**
+     * Create METHOD_CALL node
+     */
+    static create(objectName, methodName, file, line, column, options = {}) {
+        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');
+        const fullName = objectName ? `${objectName}.${methodName}` : methodName;
+        const counter = options.counter !== undefined ? `:${options.counter}` : '';
+        const id = `${file}:METHOD_CALL:${fullName}:${line}:${column || 0}${counter}`;
+        return {
+            id,
+            type: this.TYPE,
+            name: fullName,
+            object: objectName,
+            method: methodName,
+            file,
+            line,
+            column: column || 0,
+            parentScopeId: options.parentScopeId,
+            args: options.args || []
+        };
+    }
+    static validate(node) {
+        const errors = [];
+        if (node.type !== this.TYPE) {
+            errors.push(`Expected type ${this.TYPE}, got ${node.type}`);
+        }
+        const nodeRecord = node;
+        for (const field of this.REQUIRED) {
+            if (nodeRecord[field] === undefined || nodeRecord[field] === null) {
+                errors.push(`Missing required field: ${field}`);
+            }
+        }
+        return errors;
+    }
+}

package/dist/core/nodes/MethodNode.d.ts

@@ -0,0 +1,29 @@
+/**
+ * MethodNode - contract for METHOD node (class method)
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+type MethodKind = 'method' | 'get' | 'set' | 'constructor';
+interface MethodNodeRecord extends BaseNodeRecord {
+    type: 'METHOD';
+    column: number;
+    className: string;
+    async: boolean;
+    generator: boolean;
+    static: boolean;
+    kind: MethodKind;
+}
+interface MethodNodeOptions {
+    async?: boolean;
+    generator?: boolean;
+    static?: boolean;
+    kind?: MethodKind;
+}
+export declare class MethodNode {
+    static readonly TYPE: "METHOD";
+    static readonly REQUIRED: readonly ["name", "file", "line", "className"];
+    static readonly OPTIONAL: readonly ["column", "async", "generator", "static", "kind"];
+    static create(name: string, file: string, line: number, column: number, className: string, options?: MethodNodeOptions): MethodNodeRecord;
+    static validate(node: MethodNodeRecord): string[];
+}
+export type { MethodNodeRecord, MethodKind };
+//# sourceMappingURL=MethodNode.d.ts.map

package/dist/core/nodes/MethodNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MethodNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/MethodNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,KAAK,UAAU,GAAG,QAAQ,GAAG,KAAK,GAAG,KAAK,GAAG,aAAa,CAAC;AAE3D,UAAU,gBAAiB,SAAQ,cAAc;IAC/C,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,UAAU,CAAC;CAClB;AAED,UAAU,iBAAiB;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAED,qBAAa,UAAU;IACrB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAEzC,MAAM,CAAC,QAAQ,CAAC,QAAQ,iDAAkD;IAC1E,MAAM,CAAC,QAAQ,CAAC,QAAQ,8DAA+D;IAEvF,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB;IAqBnB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,EAAE;CAgBlD;AAED,YAAY,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC"}

package/dist/core/nodes/MethodNode.js

@@ -0,0 +1,44 @@
+/**
+ * MethodNode - contract for METHOD node (class method)
+ */
+export class MethodNode {
+    static TYPE = 'METHOD';
+    static REQUIRED = ['name', 'file', 'line', 'className'];
+    static OPTIONAL = ['column', 'async', 'generator', 'static', 'kind'];
+    static create(name, file, line, column, className, options = {}) {
+        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 (!className)
+            throw new Error('MethodNode.create: className is required');
+        return {
+            id: `${file}:METHOD:${className}.${name}:${line}`,
+            type: this.TYPE,
+            name,
+            file,
+            line,
+            column: column || 0,
+            className,
+            async: options.async || false,
+            generator: options.generator || false,
+            static: options.static || false,
+            kind: options.kind || 'method'
+        };
+    }
+    static validate(node) {
+        const errors = [];
+        if (node.type !== this.TYPE) {
+            errors.push(`Expected type ${this.TYPE}, got ${node.type}`);
+        }
+        const nodeRecord = node;
+        for (const field of this.REQUIRED) {
+            if (!nodeRecord[field]) {
+                errors.push(`Missing required field: ${field}`);
+            }
+        }
+        return errors;
+    }
+}

package/dist/core/nodes/ModuleNode.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ModuleNode - contract for MODULE node
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+interface ModuleNodeRecord extends BaseNodeRecord {
+    type: 'MODULE';
+    contentHash: string;
+    isTest: boolean;
+}
+interface ModuleNodeOptions {
+    isTest?: boolean;
+}
+export declare class ModuleNode {
+    static readonly TYPE: "MODULE";
+    static readonly REQUIRED: readonly ["name", "file", "contentHash"];
+    static readonly OPTIONAL: readonly ["isTest"];
+    /**
+     * Create MODULE node
+     * @param filePath - Full file path
+     * @param relativePath - Relative path (module name)
+     * @param contentHash - Content hash
+     * @param options - Additional options (isTest, etc.)
+     */
+    static create(filePath: string, relativePath: string, contentHash: string, options?: ModuleNodeOptions): ModuleNodeRecord;
+    static _hashPath(path: string): string;
+    static validate(node: ModuleNodeRecord): string[];
+}
+export type { ModuleNodeRecord };
+//# sourceMappingURL=ModuleNode.d.ts.map

package/dist/core/nodes/ModuleNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/ModuleNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,UAAU,gBAAiB,SAAQ,cAAc;IAC/C,IAAI,EAAE,QAAQ,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,UAAU,iBAAiB;IACzB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,qBAAa,UAAU;IACrB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAEzC,MAAM,CAAC,QAAQ,CAAC,QAAQ,2CAA4C;IACpE,MAAM,CAAC,QAAQ,CAAC,QAAQ,sBAAuB;IAE/C;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,CACX,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB;IAgBnB,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAItC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,EAAE;CAgBlD;AAED,YAAY,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/core/nodes/ModuleNode.js

@@ -0,0 +1,49 @@
+/**
+ * ModuleNode - contract for MODULE node
+ */
+import { createHash } from 'crypto';
+export class ModuleNode {
+    static TYPE = 'MODULE';
+    static REQUIRED = ['name', 'file', 'contentHash'];
+    static OPTIONAL = ['isTest'];
+    /**
+     * Create MODULE node
+     * @param filePath - Full file path
+     * @param relativePath - Relative path (module name)
+     * @param contentHash - Content hash
+     * @param options - Additional options (isTest, etc.)
+     */
+    static create(filePath, relativePath, contentHash, options = {}) {
+        if (!filePath)
+            throw new Error('ModuleNode.create: filePath is required');
+        if (!relativePath)
+            throw new Error('ModuleNode.create: relativePath is required');
+        if (!contentHash)
+            throw new Error('ModuleNode.create: contentHash is required');
+        return {
+            id: `MODULE:${contentHash}`,
+            type: this.TYPE,
+            name: relativePath,
+            file: filePath,
+            line: 0,
+            contentHash,
+            isTest: options.isTest || false
+        };
+    }
+    static _hashPath(path) {
+        return createHash('md5').update(path).digest('hex').substring(0, 12);
+    }
+    static validate(node) {
+        const errors = [];
+        if (node.type !== this.TYPE) {
+            errors.push(`Expected type ${this.TYPE}, got ${node.type}`);
+        }
+        const nodeRecord = node;
+        for (const field of this.REQUIRED) {
+            if (!nodeRecord[field]) {
+                errors.push(`Missing required field: ${field}`);
+            }
+        }
+        return errors;
+    }
+}

package/dist/core/nodes/NodeKind.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Node Types - string type system for nodes
+ *
+ * Base types: FUNCTION, CLASS, METHOD, etc.
+ * Namespaced types: http:route, socketio:emit, express:router, etc.
+ *
+ * Namespace convention:
+ * - http:* - HTTP endpoints and requests
+ * - express:* - Express.js specifics
+ * - socketio:* - Socket.IO
+ * - db:* - Database queries
+ * - fs:* - Filesystem operations
+ */
+export declare const NODE_TYPE: {
+    readonly FUNCTION: "FUNCTION";
+    readonly CLASS: "CLASS";
+    readonly METHOD: "METHOD";
+    readonly VARIABLE: "VARIABLE";
+    readonly PARAMETER: "PARAMETER";
+    readonly CONSTANT: "CONSTANT";
+    readonly LITERAL: "LITERAL";
+    readonly EXPRESSION: "EXPRESSION";
+    readonly MODULE: "MODULE";
+    readonly IMPORT: "IMPORT";
+    readonly EXPORT: "EXPORT";
+    readonly CALL: "CALL";
+    readonly PROJECT: "PROJECT";
+    readonly SERVICE: "SERVICE";
+    readonly FILE: "FILE";
+    readonly SCOPE: "SCOPE";
+    readonly EXTERNAL: "EXTERNAL";
+    readonly EXTERNAL_MODULE: "EXTERNAL_MODULE";
+    readonly SIDE_EFFECT: "SIDE_EFFECT";
+};
+export type BaseNodeType = typeof NODE_TYPE[keyof typeof NODE_TYPE];
+export declare const NAMESPACED_TYPE: {
+    readonly HTTP_ROUTE: "http:route";
+    readonly HTTP_REQUEST: "http:request";
+    readonly EXPRESS_ROUTER: "express:router";
+    readonly EXPRESS_MIDDLEWARE: "express:middleware";
+    readonly EXPRESS_MOUNT: "express:mount";
+    readonly SOCKETIO_EMIT: "socketio:emit";
+    readonly SOCKETIO_ON: "socketio:on";
+    readonly SOCKETIO_NAMESPACE: "socketio:namespace";
+    readonly DB_QUERY: "db:query";
+    readonly DB_CONNECTION: "db:connection";
+    readonly FS_READ: "fs:read";
+    readonly FS_WRITE: "fs:write";
+    readonly FS_OPERATION: "fs:operation";
+    readonly NET_REQUEST: "net:request";
+    readonly NET_STDIO: "net:stdio";
+    readonly EVENT_LISTENER: "event:listener";
+    readonly EVENT_EMIT: "event:emit";
+    readonly GUARANTEE_QUEUE: "guarantee:queue";
+    readonly GUARANTEE_API: "guarantee:api";
+    readonly GUARANTEE_PERMISSION: "guarantee:permission";
+};
+export type NamespacedNodeType = typeof NAMESPACED_TYPE[keyof typeof NAMESPACED_TYPE];
+export type NodeType = BaseNodeType | NamespacedNodeType | string;
+/**
+ * Check if type is namespaced (contains :)
+ */
+export declare function isNamespacedType(nodeType: string): boolean;
+/**
+ * Get namespace from type
+ * @returns namespace or null for base types
+ */
+export declare function getNamespace(nodeType: string): string | null;
+/**
+ * Get base name from namespaced type
+ */
+export declare function getBaseName(nodeType: string): string;
+/**
+ * Check if type is an endpoint (HTTP route, WebSocket handler, etc.)
+ */
+export declare function isEndpointType(nodeType: string): boolean;
+/**
+ * Check if type is a side effect (DB, FS, Network)
+ */
+export declare function isSideEffectType(nodeType: string): boolean;
+/**
+ * Check if type matches a pattern with wildcard
+ * @param nodeType - node type
+ * @param pattern - pattern (e.g., "http:*", "FUNCTION")
+ */
+export declare function matchesTypePattern(nodeType: string, pattern: string): boolean;
+/**
+ * Check if type is a guarantee type (guarantee:queue, guarantee:api, etc.)
+ */
+export declare function isGuaranteeType(nodeType: string): boolean;
+//# sourceMappingURL=NodeKind.d.ts.map

package/dist/core/nodes/NodeKind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeKind.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/NodeKind.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;CA+BZ,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,OAAO,SAAS,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAKpE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;CAoClB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,OAAO,eAAe,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC;AAGtF,MAAM,MAAM,QAAQ,GAAG,YAAY,GAAG,kBAAkB,GAAG,MAAM,CAAC;AAIlE;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG5D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAIpD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAIxD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAK1D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAa7E;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGzD"}

package/dist/core/nodes/NodeKind.js

@@ -0,0 +1,146 @@
+/**
+ * Node Types - string type system for nodes
+ *
+ * Base types: FUNCTION, CLASS, METHOD, etc.
+ * Namespaced types: http:route, socketio:emit, express:router, etc.
+ *
+ * Namespace convention:
+ * - http:* - HTTP endpoints and requests
+ * - express:* - Express.js specifics
+ * - socketio:* - Socket.IO
+ * - db:* - Database queries
+ * - fs:* - Filesystem operations
+ */
+// === BASE TYPES ===
+// Abstract types, not tied to language or framework
+export const NODE_TYPE = {
+    // Core code entities
+    FUNCTION: 'FUNCTION',
+    CLASS: 'CLASS',
+    METHOD: 'METHOD',
+    VARIABLE: 'VARIABLE',
+    PARAMETER: 'PARAMETER',
+    CONSTANT: 'CONSTANT',
+    LITERAL: 'LITERAL',
+    EXPRESSION: 'EXPRESSION', // Generic expression node for data flow tracking
+    // Module system
+    MODULE: 'MODULE',
+    IMPORT: 'IMPORT',
+    EXPORT: 'EXPORT',
+    // Call graph
+    CALL: 'CALL', // unified METHOD_CALL + CALL_SITE
+    // Project structure
+    PROJECT: 'PROJECT',
+    SERVICE: 'SERVICE',
+    FILE: 'FILE',
+    SCOPE: 'SCOPE',
+    // External dependencies
+    EXTERNAL: 'EXTERNAL',
+    EXTERNAL_MODULE: 'EXTERNAL_MODULE',
+    // Generic side effects
+    SIDE_EFFECT: 'SIDE_EFFECT',
+};
+// === NAMESPACED TYPES ===
+// Types specific to frameworks and libraries
+export const NAMESPACED_TYPE = {
+    // HTTP (generic)
+    HTTP_ROUTE: 'http:route',
+    HTTP_REQUEST: 'http:request',
+    // Express.js
+    EXPRESS_ROUTER: 'express:router',
+    EXPRESS_MIDDLEWARE: 'express:middleware',
+    EXPRESS_MOUNT: 'express:mount',
+    // Socket.IO
+    SOCKETIO_EMIT: 'socketio:emit',
+    SOCKETIO_ON: 'socketio:on',
+    SOCKETIO_NAMESPACE: 'socketio:namespace',
+    // Database
+    DB_QUERY: 'db:query',
+    DB_CONNECTION: 'db:connection',
+    // Filesystem
+    FS_READ: 'fs:read',
+    FS_WRITE: 'fs:write',
+    FS_OPERATION: 'fs:operation',
+    // Network
+    NET_REQUEST: 'net:request',
+    NET_STDIO: 'net:stdio',
+    // Events
+    EVENT_LISTENER: 'event:listener',
+    EVENT_EMIT: 'event:emit',
+    // Guarantees (contract-based)
+    GUARANTEE_QUEUE: 'guarantee:queue',
+    GUARANTEE_API: 'guarantee:api',
+    GUARANTEE_PERMISSION: 'guarantee:permission',
+};
+// === HELPERS ===
+/**
+ * Check if type is namespaced (contains :)
+ */
+export function isNamespacedType(nodeType) {
+    return nodeType !== undefined && nodeType !== null && nodeType.includes(':');
+}
+/**
+ * Get namespace from type
+ * @returns namespace or null for base types
+ */
+export function getNamespace(nodeType) {
+    if (!nodeType || !nodeType.includes(':'))
+        return null;
+    return nodeType.split(':')[0];
+}
+/**
+ * Get base name from namespaced type
+ */
+export function getBaseName(nodeType) {
+    if (!nodeType)
+        return '';
+    if (!nodeType.includes(':'))
+        return nodeType;
+    return nodeType.split(':').slice(1).join(':');
+}
+/**
+ * Check if type is an endpoint (HTTP route, WebSocket handler, etc.)
+ */
+export function isEndpointType(nodeType) {
+    if (!nodeType)
+        return false;
+    const ns = getNamespace(nodeType);
+    return ns === 'http' || ns === 'express' || ns === 'socketio';
+}
+/**
+ * Check if type is a side effect (DB, FS, Network)
+ */
+export function isSideEffectType(nodeType) {
+    if (!nodeType)
+        return false;
+    if (nodeType === NODE_TYPE.SIDE_EFFECT)
+        return true;
+    const ns = getNamespace(nodeType);
+    return ns === 'db' || ns === 'fs' || ns === 'net';
+}
+/**
+ * Check if type matches a pattern with wildcard
+ * @param nodeType - node type
+ * @param pattern - pattern (e.g., "http:*", "FUNCTION")
+ */
+export function matchesTypePattern(nodeType, pattern) {
+    if (!nodeType || !pattern)
+        return false;
+    // Exact match
+    if (nodeType === pattern)
+        return true;
+    // Wildcard match (e.g., "http:*" matches "http:route")
+    if (pattern.endsWith(':*')) {
+        const patternNs = pattern.slice(0, -2);
+        return getNamespace(nodeType) === patternNs;
+    }
+    return false;
+}
+/**
+ * Check if type is a guarantee type (guarantee:queue, guarantee:api, etc.)
+ */
+export function isGuaranteeType(nodeType) {
+    if (!nodeType)
+        return false;
+    return getNamespace(nodeType) === 'guarantee';
+}

package/dist/core/nodes/ParameterNode.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ParameterNode - contract for PARAMETER node
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+interface ParameterNodeRecord extends BaseNodeRecord {
+    type: 'PARAMETER';
+    column: number;
+    functionId: string;
+    index: number;
+    defaultValue?: unknown;
+    rest: boolean;
+}
+interface ParameterNodeOptions {
+    index?: number;
+    defaultValue?: unknown;
+    rest?: boolean;
+}
+export declare class ParameterNode {
+    static readonly TYPE: "PARAMETER";
+    static readonly REQUIRED: readonly ["name", "file", "line", "functionId"];
+    static readonly OPTIONAL: readonly ["column", "index", "defaultValue", "rest"];
+    static create(name: string, file: string, line: number, column: number, functionId: string, options?: ParameterNodeOptions): ParameterNodeRecord;
+    static validate(node: ParameterNodeRecord): string[];
+}
+export type { ParameterNodeRecord };
+//# sourceMappingURL=ParameterNode.d.ts.map

package/dist/core/nodes/ParameterNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParameterNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/ParameterNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,UAAU,mBAAoB,SAAQ,cAAc;IAClD,IAAI,EAAE,WAAW,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,IAAI,EAAE,OAAO,CAAC;CACf;AAED,UAAU,oBAAoB;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,qBAAa,aAAa;IACxB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,WAAW,CAAU;IAE5C,MAAM,CAAC,QAAQ,CAAC,QAAQ,kDAAmD;IAC3E,MAAM,CAAC,QAAQ,CAAC,QAAQ,uDAAwD;IAEhF,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,oBAAyB,GACjC,mBAAmB;IAoBtB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM,EAAE;CAgBrD;AAED,YAAY,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/core/nodes/ParameterNode.js

@@ -0,0 +1,43 @@
+/**
+ * ParameterNode - contract for PARAMETER node
+ */
+export class ParameterNode {
+    static TYPE = 'PARAMETER';
+    static REQUIRED = ['name', 'file', 'line', 'functionId'];
+    static OPTIONAL = ['column', 'index', 'defaultValue', 'rest'];
+    static create(name, file, line, column, functionId, options = {}) {
+        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 (!functionId)
+            throw new Error('ParameterNode.create: functionId is required');
+        return {
+            id: `${file}:PARAMETER:${name}:${line}:${options.index || 0}`,
+            type: this.TYPE,
+            name,
+            file,
+            line,
+            column: column || 0,
+            functionId,
+            index: options.index || 0,
+            defaultValue: options.defaultValue,
+            rest: options.rest || false
+        };
+    }
+    static validate(node) {
+        const errors = [];
+        if (node.type !== this.TYPE) {
+            errors.push(`Expected type ${this.TYPE}, got ${node.type}`);
+        }
+        const nodeRecord = node;
+        for (const field of this.REQUIRED) {
+            if (!nodeRecord[field]) {
+                errors.push(`Missing required field: ${field}`);
+            }
+        }
+        return errors;
+    }
+}

package/dist/core/nodes/ScopeNode.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ScopeNode - contract for SCOPE node
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+interface ScopeNodeRecord extends BaseNodeRecord {
+    type: 'SCOPE';
+    scopeType: string;
+    conditional: boolean;
+    parentScopeId?: string;
+    parentFunctionId?: string;
+    capturesFrom?: string[];
+}
+interface ScopeNodeOptions {
+    name?: string;
+    conditional?: boolean;
+    parentScopeId?: string;
+    parentFunctionId?: string;
+    capturesFrom?: string[];
+    counter?: number;
+}
+export declare class ScopeNode {
+    static readonly TYPE: "SCOPE";
+    static readonly REQUIRED: readonly ["scopeType", "file", "line"];
+    static readonly OPTIONAL: readonly ["name", "conditional", "parentScopeId", "parentFunctionId", "capturesFrom"];
+    /**
+     * Create SCOPE node
+     */
+    static create(scopeType: string, file: string, line: number, options?: ScopeNodeOptions): ScopeNodeRecord;
+    static validate(node: ScopeNodeRecord): string[];
+}
+export type { ScopeNodeRecord };
+//# sourceMappingURL=ScopeNode.d.ts.map

package/dist/core/nodes/ScopeNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScopeNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/ScopeNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,UAAU,eAAgB,SAAQ,cAAc;IAC9C,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,UAAU,gBAAgB;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,SAAS;IACpB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAU;IAExC,MAAM,CAAC,QAAQ,CAAC,QAAQ,yCAA0C;IAClE,MAAM,CAAC,QAAQ,CAAC,QAAQ,wFAAyF;IAEjH;;OAEG;IACH,MAAM,CAAC,MAAM,CACX,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,gBAAqB,GAC7B,eAAe;IAuBlB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,EAAE;CAgBjD;AAED,YAAY,EAAE,eAAe,EAAE,CAAC"}

package/dist/core/nodes/ScopeNode.js

@@ -0,0 +1,47 @@
+/**
+ * ScopeNode - contract for SCOPE node
+ */
+export class ScopeNode {
+    static TYPE = 'SCOPE';
+    static REQUIRED = ['scopeType', 'file', 'line'];
+    static OPTIONAL = ['name', 'conditional', 'parentScopeId', 'parentFunctionId', 'capturesFrom'];
+    /**
+     * Create SCOPE node
+     */
+    static create(scopeType, file, line, options = {}) {
+        if (!scopeType)
+            throw new Error('ScopeNode.create: scopeType is required');
+        if (!file)
+            throw new Error('ScopeNode.create: file is required');
+        if (line === undefined)
+            throw new Error('ScopeNode.create: line is required');
+        const name = options.name || scopeType;
+        const counter = options.counter !== undefined ? `:${options.counter}` : '';
+        const id = `${file}:SCOPE:${name}:${line}${counter}`;
+        return {
+            id,
+            type: this.TYPE,
+            scopeType,
+            name,
+            file,
+            line,
+            conditional: options.conditional || false,
+            parentScopeId: options.parentScopeId,
+            parentFunctionId: options.parentFunctionId,
+            capturesFrom: options.capturesFrom
+        };
+    }
+    static validate(node) {
+        const errors = [];
+        if (node.type !== this.TYPE) {
+            errors.push(`Expected type ${this.TYPE}, got ${node.type}`);
+        }
+        const nodeRecord = node;
+        for (const field of this.REQUIRED) {
+            if (nodeRecord[field] === undefined || nodeRecord[field] === null) {
+                errors.push(`Missing required field: ${field}`);
+            }
+        }
+        return errors;
+    }
+}