@grafema/core 0.1.0-alpha.1

package/dist/core/nodes/EventListenerNode.js

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

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

@@ -0,0 +1,26 @@
+/**
+ * ExportNode - contract for EXPORT node
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+type ExportKind = 'value' | 'type';
+interface ExportNodeRecord extends BaseNodeRecord {
+    type: 'EXPORT';
+    column: number;
+    exportKind: ExportKind;
+    local: string;
+    default: boolean;
+}
+interface ExportNodeOptions {
+    exportKind?: ExportKind;
+    local?: string;
+    default?: boolean;
+}
+export declare class ExportNode {
+    static readonly TYPE: "EXPORT";
+    static readonly REQUIRED: readonly ["name", "file", "line"];
+    static readonly OPTIONAL: readonly ["column", "exportKind", "local", "default"];
+    static create(name: string, file: string, line: number, column: number, options?: ExportNodeOptions): ExportNodeRecord;
+    static validate(node: ExportNodeRecord): string[];
+}
+export type { ExportNodeRecord, ExportKind };
+//# sourceMappingURL=ExportNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ExportNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/ExportNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,KAAK,UAAU,GAAG,OAAO,GAAG,MAAM,CAAC;AAEnC,UAAU,gBAAiB,SAAQ,cAAc;IAC/C,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,UAAU,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,UAAU,iBAAiB;IACzB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qBAAa,UAAU;IACrB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAEzC,MAAM,CAAC,QAAQ,CAAC,QAAQ,oCAAqC;IAC7D,MAAM,CAAC,QAAQ,CAAC,QAAQ,wDAAyD;IAEjF,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB;IAkBnB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,EAAE;CAgBlD;AAED,YAAY,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC"}

package/dist/core/nodes/ExportNode.js

@@ -0,0 +1,40 @@
+/**
+ * ExportNode - contract for EXPORT node
+ */
+export class ExportNode {
+    static TYPE = 'EXPORT';
+    static REQUIRED = ['name', 'file', 'line'];
+    static OPTIONAL = ['column', 'exportKind', 'local', 'default'];
+    static create(name, file, line, column, options = {}) {
+        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');
+        return {
+            id: `${file}:EXPORT:${name}:${line}`,
+            type: this.TYPE,
+            name,
+            file,
+            line,
+            column: column || 0,
+            exportKind: options.exportKind || 'value',
+            local: options.local || name,
+            default: options.default || 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/ExternalStdioNode.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ExternalStdioNode - contract for EXTERNAL_STDIO node (singleton)
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+interface ExternalStdioNodeRecord extends BaseNodeRecord {
+    type: 'EXTERNAL_STDIO';
+}
+export declare class ExternalStdioNode {
+    static readonly TYPE: "EXTERNAL_STDIO";
+    static readonly SINGLETON_ID = "EXTERNAL_STDIO:__stdio__";
+    static readonly REQUIRED: readonly ["name", "file"];
+    static readonly OPTIONAL: readonly [];
+    static create(): ExternalStdioNodeRecord;
+    static validate(node: ExternalStdioNodeRecord): string[];
+}
+export type { ExternalStdioNodeRecord };
+//# sourceMappingURL=ExternalStdioNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ExternalStdioNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/ExternalStdioNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,UAAU,uBAAwB,SAAQ,cAAc;IACtD,IAAI,EAAE,gBAAgB,CAAC;CACxB;AAED,qBAAa,iBAAiB;IAC5B,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,gBAAgB,CAAU;IACjD,MAAM,CAAC,QAAQ,CAAC,YAAY,8BAA8B;IAE1D,MAAM,CAAC,QAAQ,CAAC,QAAQ,4BAA6B;IACrD,MAAM,CAAC,QAAQ,CAAC,QAAQ,cAAe;IAEvC,MAAM,CAAC,MAAM,IAAI,uBAAuB;IAUxC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,uBAAuB,GAAG,MAAM,EAAE;CAMzD;AAED,YAAY,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/core/nodes/ExternalStdioNode.js

@@ -0,0 +1,26 @@
+/**
+ * ExternalStdioNode - contract for EXTERNAL_STDIO node (singleton)
+ */
+export class ExternalStdioNode {
+    static TYPE = 'EXTERNAL_STDIO';
+    static SINGLETON_ID = 'EXTERNAL_STDIO:__stdio__';
+    static REQUIRED = ['name', 'file'];
+    static OPTIONAL = [];
+    static create() {
+        return {
+            id: this.SINGLETON_ID,
+            type: this.TYPE,
+            name: '__stdio__',
+            file: '__builtin__',
+            line: 0
+        };
+    }
+    static validate(node) {
+        const errors = [];
+        if (node.type !== this.TYPE)
+            errors.push(`Expected type ${this.TYPE}`);
+        if (node.id !== this.SINGLETON_ID)
+            errors.push(`Invalid singleton ID`);
+        return errors;
+    }
+}

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

@@ -0,0 +1,27 @@
+/**
+ * FunctionNode - contract for FUNCTION node
+ */
+import type { FunctionNodeRecord } from '@grafema/types';
+interface FunctionNodeOptions {
+    async?: boolean;
+    generator?: boolean;
+    exported?: boolean;
+    arrowFunction?: boolean;
+    parentScopeId?: string;
+    isClassMethod?: boolean;
+    className?: string;
+    params?: string[];
+    counter?: number;
+}
+export declare class FunctionNode {
+    static readonly TYPE: "FUNCTION";
+    static readonly REQUIRED: readonly ["name", "file", "line", "column"];
+    static readonly OPTIONAL: readonly ["async", "generator", "exported", "arrowFunction", "parentScopeId", "isClassMethod", "className", "params"];
+    /**
+     * Create FUNCTION node
+     */
+    static create(name: string, file: string, line: number, column: number, options?: FunctionNodeOptions): FunctionNodeRecord;
+    static validate(node: FunctionNodeRecord): string[];
+}
+export {};
+//# sourceMappingURL=FunctionNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/FunctionNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,UAAU,mBAAmB;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,YAAY;IACvB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,UAAU,CAAU;IAE3C,MAAM,CAAC,QAAQ,CAAC,QAAQ,8CAA+C;IACvE,MAAM,CAAC,QAAQ,CAAC,QAAQ,wHAAyH;IAEjJ;;OAEG;IACH,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,mBAAwB,GAChC,kBAAkB;IA4BrB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,EAAE;CAgBpD"}

package/dist/core/nodes/FunctionNode.js

@@ -0,0 +1,53 @@
+/**
+ * FunctionNode - contract for FUNCTION node
+ */
+export class FunctionNode {
+    static TYPE = 'FUNCTION';
+    static REQUIRED = ['name', 'file', 'line', 'column'];
+    static OPTIONAL = ['async', 'generator', 'exported', 'arrowFunction', 'parentScopeId', 'isClassMethod', 'className', 'params'];
+    /**
+     * Create FUNCTION node
+     */
+    static create(name, file, line, column, options = {}) {
+        if (!name)
+            throw new Error('FunctionNode.create: name is required');
+        if (!file)
+            throw new Error('FunctionNode.create: file is required');
+        if (line === undefined)
+            throw new Error('FunctionNode.create: line is required');
+        if (column === undefined)
+            throw new Error('FunctionNode.create: column is required');
+        const counter = options.counter !== undefined ? `:${options.counter}` : '';
+        const id = `${file}:FUNCTION:${name}:${line}:${column}${counter}`;
+        return {
+            id,
+            stableId: id,
+            type: this.TYPE,
+            name,
+            file,
+            line,
+            column,
+            async: options.async || false,
+            generator: options.generator || false,
+            exported: options.exported || false,
+            arrowFunction: options.arrowFunction || false,
+            parentScopeId: options.parentScopeId,
+            isClassMethod: options.isClassMethod || false,
+            className: options.className,
+            params: options.params || []
+        };
+    }
+    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/GuaranteeNode.d.ts

@@ -0,0 +1,76 @@
+/**
+ * GuaranteeNode - contract for contract-based guarantee nodes
+ *
+ * Types: guarantee:queue, guarantee:api, guarantee:permission
+ * ID format: guarantee:queue#orders, guarantee:api#rate-limit
+ *
+ * Unlike Datalog-based GUARANTEE nodes (handled by GuaranteeManager),
+ * these nodes use JSON schema validation for contract verification.
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+export type GuaranteePriority = 'critical' | 'important' | 'observed' | 'tracked';
+export type GuaranteeStatus = 'discovered' | 'reviewed' | 'active' | 'changing' | 'deprecated';
+export type GuaranteeType = 'guarantee:queue' | 'guarantee:api' | 'guarantee:permission';
+export interface GuaranteeNodeRecord extends BaseNodeRecord {
+    type: GuaranteeType;
+    priority: GuaranteePriority;
+    status: GuaranteeStatus;
+    owner?: string;
+    schema?: Record<string, unknown>;
+    condition?: string;
+    description?: string;
+    createdAt?: number;
+    updatedAt?: number;
+}
+export interface GuaranteeNodeOptions {
+    priority?: GuaranteePriority;
+    status?: GuaranteeStatus;
+    owner?: string;
+    schema?: Record<string, unknown>;
+    condition?: string;
+    description?: string;
+}
+declare const GUARANTEE_NAMESPACES: readonly ["queue", "api", "permission"];
+type GuaranteeNamespace = typeof GUARANTEE_NAMESPACES[number];
+export declare class GuaranteeNode {
+    static readonly TYPE_QUEUE: "guarantee:queue";
+    static readonly TYPE_API: "guarantee:api";
+    static readonly TYPE_PERMISSION: "guarantee:permission";
+    static readonly REQUIRED: readonly ["name", "file", "priority", "status"];
+    static readonly OPTIONAL: readonly ["owner", "schema", "condition", "description", "createdAt", "updatedAt"];
+    /**
+     * Create guarantee node
+     * @param namespace - guarantee namespace (queue, api, permission)
+     * @param name - guarantee name (e.g., 'orders', 'rate-limit')
+     * @param options - optional fields
+     */
+    static create(namespace: GuaranteeNamespace, name: string, options?: GuaranteeNodeOptions): GuaranteeNodeRecord;
+    /**
+     * Validate guarantee node
+     * @returns array of error messages, empty if valid
+     */
+    static validate(node: GuaranteeNodeRecord): string[];
+    /**
+     * Parse guarantee ID into components
+     * @param id - full ID (e.g., 'guarantee:queue#orders')
+     * @returns { namespace, name } or null if invalid
+     */
+    static parseId(id: string): {
+        namespace: GuaranteeNamespace;
+        name: string;
+    } | null;
+    /**
+     * Build ID from components
+     */
+    static buildId(namespace: GuaranteeNamespace, name: string): string;
+    /**
+     * Check if node type is a guarantee type
+     */
+    static isGuaranteeType(type: string): boolean;
+    /**
+     * Get all valid guarantee types
+     */
+    static getTypes(): GuaranteeType[];
+}
+export {};
+//# sourceMappingURL=GuaranteeNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GuaranteeNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/GuaranteeNode.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAIrD,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,SAAS,CAAC;AAClF,MAAM,MAAM,eAAe,GAAG,YAAY,GAAG,UAAU,GAAG,QAAQ,GAAG,UAAU,GAAG,YAAY,CAAC;AAC/F,MAAM,MAAM,aAAa,GAAG,iBAAiB,GAAG,eAAe,GAAG,sBAAsB,CAAC;AAEzF,MAAM,WAAW,mBAAoB,SAAQ,cAAc;IACzD,IAAI,EAAE,aAAa,CAAC;IACpB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,MAAM,EAAE,eAAe,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAGD,QAAA,MAAM,oBAAoB,yCAA0C,CAAC;AACrE,KAAK,kBAAkB,GAAG,OAAO,oBAAoB,CAAC,MAAM,CAAC,CAAC;AAE9D,qBAAa,aAAa;IACxB,MAAM,CAAC,QAAQ,CAAC,UAAU,oBAAmC;IAC7D,MAAM,CAAC,QAAQ,CAAC,QAAQ,kBAAiC;IACzD,MAAM,CAAC,QAAQ,CAAC,eAAe,yBAAwC;IAEvE,MAAM,CAAC,QAAQ,CAAC,QAAQ,kDAAmD;IAC3E,MAAM,CAAC,QAAQ,CAAC,QAAQ,qFAAsF;IAE9G;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CACX,SAAS,EAAE,kBAAkB,EAC7B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,oBAAyB,GACjC,mBAAmB;IA4BtB;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM,EAAE;IA0BpD;;;;OAIG;IACH,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG;QAAE,SAAS,EAAE,kBAAkB,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAalF;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;IAInE;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI7C;;OAEG;IACH,MAAM,CAAC,QAAQ,IAAI,aAAa,EAAE;CAOnC"}

package/dist/core/nodes/GuaranteeNode.js

@@ -0,0 +1,117 @@
+/**
+ * GuaranteeNode - contract for contract-based guarantee nodes
+ *
+ * Types: guarantee:queue, guarantee:api, guarantee:permission
+ * ID format: guarantee:queue#orders, guarantee:api#rate-limit
+ *
+ * Unlike Datalog-based GUARANTEE nodes (handled by GuaranteeManager),
+ * these nodes use JSON schema validation for contract verification.
+ */
+import { NAMESPACED_TYPE, isGuaranteeType } from './NodeKind.js';
+// Valid guarantee namespaces
+const GUARANTEE_NAMESPACES = ['queue', 'api', 'permission'];
+export class GuaranteeNode {
+    static TYPE_QUEUE = NAMESPACED_TYPE.GUARANTEE_QUEUE;
+    static TYPE_API = NAMESPACED_TYPE.GUARANTEE_API;
+    static TYPE_PERMISSION = NAMESPACED_TYPE.GUARANTEE_PERMISSION;
+    static REQUIRED = ['name', 'file', 'priority', 'status'];
+    static OPTIONAL = ['owner', 'schema', 'condition', 'description', 'createdAt', 'updatedAt'];
+    /**
+     * Create guarantee node
+     * @param namespace - guarantee namespace (queue, api, permission)
+     * @param name - guarantee name (e.g., 'orders', 'rate-limit')
+     * @param options - optional fields
+     */
+    static create(namespace, name, options = {}) {
+        if (!namespace)
+            throw new Error('GuaranteeNode.create: namespace is required');
+        if (!name)
+            throw new Error('GuaranteeNode.create: name is required');
+        if (!GUARANTEE_NAMESPACES.includes(namespace)) {
+            throw new Error(`GuaranteeNode.create: invalid namespace "${namespace}". Valid: ${GUARANTEE_NAMESPACES.join(', ')}`);
+        }
+        const type = `guarantee:${namespace}`;
+        const id = `${type}#${name}`;
+        const now = Date.now();
+        return {
+            id,
+            type,
+            name,
+            file: '', // Guarantees don't have a source file
+            line: undefined,
+            priority: options.priority || 'observed',
+            status: options.status || 'discovered',
+            owner: options.owner,
+            schema: options.schema,
+            condition: options.condition,
+            description: options.description,
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    /**
+     * Validate guarantee node
+     * @returns array of error messages, empty if valid
+     */
+    static validate(node) {
+        const errors = [];
+        if (!isGuaranteeType(node.type)) {
+            errors.push(`Expected guarantee:* type, got ${node.type}`);
+        }
+        if (!node.name) {
+            errors.push('Missing required field: name');
+        }
+        if (!node.priority) {
+            errors.push('Missing required field: priority');
+        }
+        else if (!['critical', 'important', 'observed', 'tracked'].includes(node.priority)) {
+            errors.push(`Invalid priority: ${node.priority}. Valid: critical, important, observed, tracked`);
+        }
+        if (!node.status) {
+            errors.push('Missing required field: status');
+        }
+        else if (!['discovered', 'reviewed', 'active', 'changing', 'deprecated'].includes(node.status)) {
+            errors.push(`Invalid status: ${node.status}. Valid: discovered, reviewed, active, changing, deprecated`);
+        }
+        return errors;
+    }
+    /**
+     * Parse guarantee ID into components
+     * @param id - full ID (e.g., 'guarantee:queue#orders')
+     * @returns { namespace, name } or null if invalid
+     */
+    static parseId(id) {
+        if (!id)
+            return null;
+        // Format: guarantee:namespace#name
+        const match = id.match(/^guarantee:(queue|api|permission)#(.+)$/);
+        if (!match)
+            return null;
+        return {
+            namespace: match[1],
+            name: match[2],
+        };
+    }
+    /**
+     * Build ID from components
+     */
+    static buildId(namespace, name) {
+        return `guarantee:${namespace}#${name}`;
+    }
+    /**
+     * Check if node type is a guarantee type
+     */
+    static isGuaranteeType(type) {
+        return isGuaranteeType(type);
+    }
+    /**
+     * Get all valid guarantee types
+     */
+    static getTypes() {
+        return [
+            NAMESPACED_TYPE.GUARANTEE_QUEUE,
+            NAMESPACED_TYPE.GUARANTEE_API,
+            NAMESPACED_TYPE.GUARANTEE_PERMISSION,
+        ];
+    }
+}

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

@@ -0,0 +1,24 @@
+/**
+ * HttpRequestNode - contract for HTTP_REQUEST node
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+interface HttpRequestNodeRecord extends BaseNodeRecord {
+    type: 'HTTP_REQUEST';
+    url?: string;
+    method: string;
+    parentScopeId?: string;
+}
+interface HttpRequestNodeOptions {
+    column?: number;
+    parentScopeId?: string;
+    counter?: number;
+}
+export declare class HttpRequestNode {
+    static readonly TYPE: "HTTP_REQUEST";
+    static readonly REQUIRED: readonly ["name", "file", "line"];
+    static readonly OPTIONAL: readonly ["url", "method", "column", "parentScopeId"];
+    static create(url: string | undefined, method: string | undefined, file: string, line: number, options?: HttpRequestNodeOptions): HttpRequestNodeRecord;
+    static validate(node: HttpRequestNodeRecord): string[];
+}
+export type { HttpRequestNodeRecord };
+//# sourceMappingURL=HttpRequestNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HttpRequestNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/HttpRequestNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,UAAU,qBAAsB,SAAQ,cAAc;IACpD,IAAI,EAAE,cAAc,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,UAAU,sBAAsB;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,eAAe;IAC1B,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,cAAc,CAAU;IAE/C,MAAM,CAAC,QAAQ,CAAC,QAAQ,oCAAqC;IAC7D,MAAM,CAAC,QAAQ,CAAC,QAAQ,wDAAyD;IAEjF,MAAM,CAAC,MAAM,CACX,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,sBAA2B,GACnC,qBAAqB;IAoBxB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,qBAAqB,GAAG,MAAM,EAAE;CASvD;AAED,YAAY,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/core/nodes/HttpRequestNode.js

@@ -0,0 +1,38 @@
+/**
+ * HttpRequestNode - contract for HTTP_REQUEST node
+ */
+export class HttpRequestNode {
+    static TYPE = 'HTTP_REQUEST';
+    static REQUIRED = ['name', 'file', 'line'];
+    static OPTIONAL = ['url', 'method', 'column', 'parentScopeId'];
+    static create(url, method, file, line, options = {}) {
+        if (!file)
+            throw new Error('HttpRequestNode.create: file is required');
+        if (line === undefined)
+            throw new Error('HttpRequestNode.create: line is required');
+        const httpMethod = method || 'GET';
+        const counter = options.counter !== undefined ? `:${options.counter}` : '';
+        const id = `${file}:HTTP_REQUEST:${httpMethod}:${line}:${options.column || 0}${counter}`;
+        return {
+            id,
+            type: this.TYPE,
+            name: `${httpMethod} ${url || 'dynamic'}`,
+            url,
+            method: httpMethod,
+            file,
+            line,
+            parentScopeId: options.parentScopeId
+        };
+    }
+    static validate(node) {
+        const errors = [];
+        if (node.type !== this.TYPE)
+            errors.push(`Expected type ${this.TYPE}`);
+        const nodeRecord = node;
+        for (const field of this.REQUIRED) {
+            if (nodeRecord[field] === undefined)
+                errors.push(`Missing: ${field}`);
+        }
+        return errors;
+    }
+}

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

@@ -0,0 +1,27 @@
+/**
+ * ImportNode - contract for IMPORT node
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+type ImportKind = 'value' | 'type' | 'typeof';
+interface ImportNodeRecord extends BaseNodeRecord {
+    type: 'IMPORT';
+    column: number;
+    source: string;
+    importKind: ImportKind;
+    imported: string;
+    local: string;
+}
+interface ImportNodeOptions {
+    importKind?: ImportKind;
+    imported?: string;
+    local?: string;
+}
+export declare class ImportNode {
+    static readonly TYPE: "IMPORT";
+    static readonly REQUIRED: readonly ["name", "file", "line", "source"];
+    static readonly OPTIONAL: readonly ["column", "importKind", "imported", "local"];
+    static create(name: string, file: string, line: number, column: number, source: string, options?: ImportNodeOptions): ImportNodeRecord;
+    static validate(node: ImportNodeRecord): string[];
+}
+export type { ImportNodeRecord, ImportKind };
+//# sourceMappingURL=ImportNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ImportNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/ImportNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,KAAK,UAAU,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE9C,UAAU,gBAAiB,SAAQ,cAAc;IAC/C,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,UAAU,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,UAAU,iBAAiB;IACzB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,UAAU;IACrB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAEzC,MAAM,CAAC,QAAQ,CAAC,QAAQ,8CAA+C;IACvE,MAAM,CAAC,QAAQ,CAAC,QAAQ,yDAA0D;IAElF,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB;IAoBnB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,EAAE;CAgBlD;AAED,YAAY,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC"}

package/dist/core/nodes/ImportNode.js

@@ -0,0 +1,43 @@
+/**
+ * ImportNode - contract for IMPORT node
+ */
+export class ImportNode {
+    static TYPE = 'IMPORT';
+    static REQUIRED = ['name', 'file', 'line', 'source'];
+    static OPTIONAL = ['column', 'importKind', 'imported', 'local'];
+    static create(name, file, line, column, source, options = {}) {
+        if (!name)
+            throw new Error('ImportNode.create: name is required');
+        if (!file)
+            throw new Error('ImportNode.create: file is required');
+        if (!line)
+            throw new Error('ImportNode.create: line is required');
+        if (!source)
+            throw new Error('ImportNode.create: source is required');
+        return {
+            id: `${file}:IMPORT:${name}:${line}`,
+            type: this.TYPE,
+            name,
+            file,
+            line,
+            column: column || 0,
+            source,
+            importKind: options.importKind || 'value',
+            imported: options.imported || name,
+            local: options.local || name
+        };
+    }
+    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/LiteralNode.d.ts

@@ -0,0 +1,26 @@
+/**
+ * LiteralNode - contract for LITERAL node
+ */
+import type { BaseNodeRecord } from '@grafema/types';
+interface LiteralNodeRecord extends BaseNodeRecord {
+    type: 'LITERAL';
+    value: unknown;
+    valueType: string;
+    column: number;
+    parentCallId?: string;
+    argIndex?: number;
+}
+interface LiteralNodeOptions {
+    parentCallId?: string;
+    argIndex?: number;
+    counter?: number;
+}
+export declare class LiteralNode {
+    static readonly TYPE: "LITERAL";
+    static readonly REQUIRED: readonly ["file", "line"];
+    static readonly OPTIONAL: readonly ["value", "valueType", "column", "parentCallId", "argIndex"];
+    static create(value: unknown, file: string, line: number, column: number, options?: LiteralNodeOptions): LiteralNodeRecord;
+    static validate(node: LiteralNodeRecord): string[];
+}
+export type { LiteralNodeRecord };
+//# sourceMappingURL=LiteralNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LiteralNode.d.ts","sourceRoot":"","sources":["../../../src/core/nodes/LiteralNode.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,UAAU,iBAAkB,SAAQ,cAAc;IAChD,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,kBAAkB;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,WAAW;IACtB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAG,SAAS,CAAU;IAE1C,MAAM,CAAC,QAAQ,CAAC,QAAQ,4BAA6B;IACrD,MAAM,CAAC,QAAQ,CAAC,QAAQ,wEAAyE;IAEjG,MAAM,CAAC,MAAM,CACX,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,kBAAuB,GAC/B,iBAAiB;IAsBpB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,EAAE;CASnD;AAED,YAAY,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/core/nodes/LiteralNode.js

@@ -0,0 +1,40 @@
+/**
+ * LiteralNode - contract for LITERAL node
+ */
+export class LiteralNode {
+    static TYPE = 'LITERAL';
+    static REQUIRED = ['file', 'line'];
+    static OPTIONAL = ['value', 'valueType', 'column', 'parentCallId', 'argIndex'];
+    static create(value, file, line, column, options = {}) {
+        if (!file)
+            throw new Error('LiteralNode.create: file is required');
+        if (line === undefined)
+            throw new Error('LiteralNode.create: line 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}`;
+        return {
+            id,
+            type: this.TYPE,
+            name: file,
+            value,
+            valueType: typeof value,
+            file,
+            line,
+            column: column || 0,
+            parentCallId: options.parentCallId,
+            argIndex: options.argIndex
+        };
+    }
+    static validate(node) {
+        const errors = [];
+        if (node.type !== this.TYPE)
+            errors.push(`Expected type ${this.TYPE}`);
+        const nodeRecord = node;
+        for (const field of this.REQUIRED) {
+            if (nodeRecord[field] === undefined)
+                errors.push(`Missing: ${field}`);
+        }
+        return errors;
+    }
+}