@yesprasad/fluent-graph 0.1.0 → 0.2.1

package/dist/cli/utils/display.js

@@ -4,35 +4,93 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.displayLineageMap = displayLineageMap;
+const path_1 = __importDefault(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
 const cli_table3_1 = __importDefault(require("cli-table3"));
-function displayLineageMap(graph) {
+function displayLineageMap(graph, registry) {
     console.log(chalk_1.default.yellow.bold('\n📊 LINEAGE MAP'));
     console.log(chalk_1.default.gray('═'.repeat(80)));
-    // ===== SECTION 1: DATA SCHEMA =====
-    const dataTables = graph.nodes.filter(node => node.table === 'sys_db_object' && node.action !== 'DELETE');
-    if (dataTables.length > 0) {
-        console.log(chalk_1.default.cyan.bold('\n📦 DATA SCHEMA'));
-        const table = new cli_table3_1.default({
-            head: [
-                chalk_1.default.cyan('Table Name'),
-                chalk_1.default.cyan('Status'),
-                chalk_1.default.cyan('Source File')
-            ],
-            wordWrap: true,
-            style: { head: [], border: ['gray'] }
-        });
-        dataTables.forEach(tableNode => {
-            const statusLabel = tableNode.action === 'DELETE' ? chalk_1.default.red('DELETE') : chalk_1.default.green('ACTIVE');
-            table.push([
-                chalk_1.default.white(tableNode.name),
-                statusLabel,
-                chalk_1.default.gray(tableNode.source.file)
-            ]);
-        });
-        console.log(table.toString());
+    // ===== DYNAMIC PLUGIN GROUPS =====
+    const pluginGroups = new Map();
+    for (const node of graph.nodes) {
+        if (node.action === 'DELETE')
+            continue;
+        const groupName = registry.getDisplayGroupName(node.table);
+        if (!pluginGroups.has(groupName)) {
+            pluginGroups.set(groupName, []);
+        }
+        pluginGroups.get(groupName).push(node);
+    }
+    for (const [groupName, nodes] of pluginGroups) {
+        // Only show primary (non-child) nodes in the section
+        const primaryNodes = nodes.filter(n => !registry.isChild(n.table) && n.source.file);
+        if (primaryNodes.length === 0)
+            continue;
+        console.log(chalk_1.default.cyan.bold(`\n${groupName}`));
+        const isBusinessRuleGroup = primaryNodes.some(n => registry.getPluginName(n.table) === 'BusinessRulePlugin');
+        if (isBusinessRuleGroup) {
+            const table = new cli_table3_1.default({
+                head: [
+                    chalk_1.default.cyan('Name'),
+                    chalk_1.default.cyan('When'),
+                    chalk_1.default.cyan('Table'),
+                    chalk_1.default.cyan('On'),
+                    chalk_1.default.cyan('Order'),
+                    chalk_1.default.cyan('Status'),
+                    chalk_1.default.cyan('File'),
+                ],
+                colWidths: [32, 8, 28, 16, 7, 8, 28],
+                wordWrap: true,
+                style: { head: [], border: ['gray'] },
+            });
+            primaryNodes.forEach(node => {
+                const statusLabel = node.action === 'DELETE' ? chalk_1.default.red('DELETE') : chalk_1.default.green('ACTIVE');
+                const when = node.attributes.when || '';
+                const depEdge = graph.edges.find(e => e.from === node.id && e.type === 'dependency' && e.targetTable);
+                const targetTable = depEdge?.targetTable || '';
+                const ops = [];
+                if (node.attributes.action_insert)
+                    ops.push('Insert');
+                if (node.attributes.action_update)
+                    ops.push('Update');
+                if (node.attributes.action_delete)
+                    ops.push('Delete');
+                if (node.attributes.action_query)
+                    ops.push('Query');
+                table.push([
+                    chalk_1.default.white(node.name),
+                    chalk_1.default.yellow(when),
+                    chalk_1.default.magenta(targetTable),
+                    ops.length ? ops.join(', ') : chalk_1.default.gray('—'),
+                    String(node.attributes.order ?? ''),
+                    statusLabel,
+                    chalk_1.default.gray(path_1.default.basename(node.source.file)),
+                ]);
+            });
+            console.log(table.toString());
+        }
+        else {
+            const table = new cli_table3_1.default({
+                head: [
+                    chalk_1.default.cyan('Name'),
+                    chalk_1.default.cyan('Status'),
+                    chalk_1.default.cyan('Source File')
+                ],
+                wordWrap: true,
+                style: { head: [], border: ['gray'] }
+            });
+            primaryNodes.forEach(node => {
+                const statusLabel = node.action === 'DELETE' ? chalk_1.default.red('DELETE') : chalk_1.default.green('ACTIVE');
+                table.push([
+                    chalk_1.default.white(node.name),
+                    statusLabel,
+                    chalk_1.default.gray(node.source.file)
+                ]);
+            });
+            console.log(table.toString());
+        }
     }
-    // ===== SECTION 2: SCHEMA RELATIONSHIPS =====
+    // ===== SCHEMA RELATIONSHIPS =====
     const schemaEdges = graph.edges.filter(edge => edge.type === 'schema_relationship');
     if (schemaEdges.length > 0) {
         console.log(chalk_1.default.cyan.bold('\n🔗 SCHEMA RELATIONSHIPS (Reference Fields)'));
@@ -56,111 +114,18 @@ function displayLineageMap(graph) {
         });
         console.log(table.toString());
     }
-    // ===== SECTION 3: LOGIC ATTACHMENTS =====
-    const logicArtifacts = graph.nodes.filter(node => ['sys_script_client', 'sys_ui_action', 'sys_script', 'sys_script_include', 'sys_ui_policy'].includes(node.table) &&
-        node.action !== 'DELETE' &&
-        node.source.file);
-    if (logicArtifacts.length > 0) {
-        console.log(chalk_1.default.cyan.bold('\n⚙️  LOGIC ATTACHMENTS (Scripts & Actions)'));
-        const table = new cli_table3_1.default({
-            head: [
-                chalk_1.default.cyan('Artifact Name'),
-                chalk_1.default.cyan('Target Table'),
-                chalk_1.default.cyan('Type'),
-                chalk_1.default.cyan('Artifact Type')
-            ],
-            wordWrap: true,
-            style: { head: [], border: ['gray'] }
-        });
-        logicArtifacts.forEach(logicNode => {
-            const dependencyEdge = graph.edges.find(edge => edge.from === logicNode.id && edge.type === 'dependency');
-            const targetTable = dependencyEdge
-                ? (dependencyEdge.to.startsWith('platform:')
-                    ? dependencyEdge.to.split(':')[1]
-                    : graph.nodes.find(node => node.id === dependencyEdge.to)?.name || dependencyEdge.to)
-                : '[global]';
-            const typeLabel = logicNode.attributes?.type ? `[${logicNode.attributes.type}]` : '[action]';
-            const artifactType = (() => {
-                switch (logicNode.table) {
-                    case 'sys_script_client': return 'client script';
-                    case 'sys_script': return 'script';
-                    case 'sys_ui_action': return 'ui action';
-                    case 'sys_script_include': return 'script include';
-                    case 'sys_ui_policy': return 'ui policy';
-                    default: return logicNode.table;
-                }
-            })();
-            table.push([
-                chalk_1.default.white(logicNode.name),
-                chalk_1.default.gray(targetTable),
-                chalk_1.default.gray(typeLabel),
-                artifactType
-            ]);
-        });
-        console.log(table.toString());
-    }
-    // ===== SECTION 4: SECURITY & ACCESS (ACLs) =====
-    const aclNodes = graph.nodes.filter(node => node.table === 'sys_security_acl' && node.action !== 'DELETE');
-    if (aclNodes.length > 0) {
-        console.log(chalk_1.default.cyan.bold('\n🔒 SECURITY & ACCESS (ACLs)'));
-        const table = new cli_table3_1.default({
-            head: [
-                chalk_1.default.cyan('ACL'),
-                chalk_1.default.cyan('Level'),
-                chalk_1.default.cyan('Operation'),
-                chalk_1.default.cyan('Roles'),
-                chalk_1.default.cyan('Target Table')
-            ],
-            wordWrap: true,
-            style: { head: [], border: ['gray'] }
-        });
-        aclNodes.forEach(aclNode => {
-            const aclEdge = graph.edges.find(edge => edge.from === aclNode.id && edge.type === 'dependency');
-            const targetTable = aclEdge?.targetTable || (aclEdge?.to.startsWith('platform:') ? aclEdge.to.split(':')[1] : 'unknown');
-            const [nameTable, nameField] = aclNode.name.includes('.') ? aclNode.name.split('.') : [aclNode.name, '*'];
-            const isFieldLevel = nameField !== '*' && nameField !== undefined;
-            const level = isFieldLevel ? 'Field-level' : 'Table-level';
-            const operation = (aclNode.attributes?.operation || 'read').toUpperCase();
-            const roleEdges = graph.edges.filter(edge => edge.from === aclNode.id && edge.type === 'composition');
-            const roleNames = roleEdges
-                .map(edge => {
-                const roleNode = graph.nodes.find(node => node.id === edge.to);
-                return roleNode?.attributes?.name || roleNode?.name || 'unknown';
-            })
-                .filter(Boolean)
-                .sort();
-            const rolesDisplay = roleNames.length > 0 ? roleNames.join(', ') : chalk_1.default.gray('No roles specified');
-            const aclLabel = `${operation} on ${nameTable}${isFieldLevel ? `.${nameField}` : ''}`;
-            table.push([
-                chalk_1.default.yellow(aclLabel),
-                chalk_1.default.gray(level),
-                chalk_1.default.gray(operation),
-                rolesDisplay,
-                chalk_1.default.magenta(targetTable)
-            ]);
-        });
-        console.log(table.toString());
-    }
-    // ===== SECTION 5: PROJECT INSIGHTS =====
+    // ===== PROJECT INSIGHTS =====
     console.log(chalk_1.default.cyan.bold('\n🧠 PROJECT INSIGHTS'));
     const platformDeps = graph.edges.filter(edge => edge.to.startsWith('platform:')).length;
     const internalDeps = graph.edges.filter(edge => !edge.to.startsWith('platform:')).length;
-    const userArtifactTables = [
-        'sys_db_object',
-        'sys_script_client',
-        'sys_script',
-        'sys_business_rule',
-        'sys_ui_action',
-        'sys_security_acl',
-        'sys_script_include'
-    ];
     const userArtifacts = graph.nodes.filter(node => node.action !== 'DELETE' &&
         node.source.file &&
         !node.id.startsWith('platform:') &&
-        userArtifactTables.includes(node.table));
+        !registry.isChild(node.table));
     console.log(` • Total User Artifacts: ${chalk_1.default.cyan(userArtifacts.length)}`);
     const countsByType = userArtifacts.reduce((acc, node) => {
-        acc[node.table] = (acc[node.table] || 0) + 1;
+        const groupName = registry.getDisplayGroupName(node.table);
+        acc[groupName] = (acc[groupName] || 0) + 1;
         return acc;
     }, {});
     console.log(` • User Artifacts Breakdown: ${JSON.stringify(countsByType, null, 2)}`);

package/dist/extractor/edges.d.ts

@@ -1,11 +1,13 @@
 import type { ArtifactEdge, ArtifactNode } from '../types/graphs';
+import type { ArtifactTypeRegistry } from '../sdk/registry';
 /**
  * UNIVERSAL EDGE EXTRACTOR
  *
  * Strategy:
- * 1. For every record, scan ALL properties
- * 2. If a property looks like a reference (RecordId or string table name), create an edge
- * 3. No hardcoded artifact types
+ * 1. Property-based schema relationship detection (internal_type=reference)
+ * 2. Logic attachment via table/collection property
+ * 3. ACL name parsing — detected via registry plugin name
+ * 4. Universal RecordId scan across all properties
  */
-export declare function extractReferenceEdges(records: any, allNodes: ArtifactNode[]): ArtifactEdge[];
+export declare function extractReferenceEdges(records: any, allNodes: ArtifactNode[], registry: ArtifactTypeRegistry): ArtifactEdge[];
 export declare function extractCompositionEdges(records: any): ArtifactEdge[];

package/dist/extractor/edges.js

@@ -6,31 +6,30 @@ exports.extractCompositionEdges = extractCompositionEdges;
  * UNIVERSAL EDGE EXTRACTOR
  *
  * Strategy:
- * 1. For every record, scan ALL properties
- * 2. If a property looks like a reference (RecordId or string table name), create an edge
- * 3. No hardcoded artifact types
+ * 1. Property-based schema relationship detection (internal_type=reference)
+ * 2. Logic attachment via table/collection property
+ * 3. ACL name parsing — detected via registry plugin name
+ * 4. Universal RecordId scan across all properties
  */
-function extractReferenceEdges(records, allNodes) {
+function extractReferenceEdges(records, allNodes, registry) {
     const edges = [];
     for (const record of records.query()) {
         const fromId = record.getId()?.getValue()?.toString();
         const props = record.setProperties || {};
         const recordTable = record.getTable()?.toString();
         // === STRATEGY 1: SCHEMA RELATIONSHIPS ===
-        // Extract reference fields from sys_dictionary records
-        if (recordTable === 'sys_dictionary') {
-            const internalType = props.internal_type?.getValue?.()?.toString();
-            const refTable = props.reference?.getValue?.()?.toString();
-            const elementName = props.element?.getValue?.()?.toString();
-            if (internalType === 'reference' && refTable) {
-                const targetNode = allNodes.find(n => n.name === refTable);
-                edges.push({
-                    from: fromId,
-                    to: targetNode?.id || `platform:${refTable}`,
-                    via: elementName || 'reference',
-                    type: 'schema_relationship'
-                });
-            }
+        // Detect by properties: any record with internal_type=reference and a reference property
+        const internalType = props.internal_type?.getValue?.()?.toString();
+        const refTable = props.reference?.getValue?.()?.toString();
+        const elementName = props.element?.getValue?.()?.toString();
+        if (internalType === 'reference' && refTable) {
+            const targetNode = allNodes.find(n => n.name === refTable);
+            edges.push({
+                from: fromId,
+                to: targetNode?.id || `platform:${refTable}`,
+                via: elementName || 'reference',
+                type: 'schema_relationship'
+            });
         }
         // === STRATEGY 2: LOGIC ATTACHMENTS ===
         // Any artifact with 'table' or 'collection' property
@@ -43,12 +42,12 @@ function extractReferenceEdges(records, allNodes) {
                 to: targetNode?.id || `platform:${tableRef}`,
                 via: props.table ? 'table' : 'collection',
                 type: 'dependency',
-                targetTable: tableRef // Added: Set targetTable for consistency (fixes fallback in display for platform tables)
+                targetTable: tableRef
             });
         }
         // === STRATEGY 3: ACL NAME PARSING ===
-        // sys_security_acl uses 'name' field like 'task.description'
-        if (recordTable === 'sys_security_acl') {
+        // Detect ACL records by plugin name (registry-derived) rather than hardcoded table name
+        if (registry.getPluginName(recordTable) === 'AclPlugin') {
             const aclName = props.name?.getValue?.()?.toString();
             if (aclName && aclName.includes('.')) {
                 const [targetTable] = aclName.split('.');
@@ -63,15 +62,17 @@ function extractReferenceEdges(records, allNodes) {
             }
         }
         // === STRATEGY 4: UNIVERSAL REFERENCE SCAN ===
-        // Scan ALL properties for RecordId types (sys_id references)
+        // Scan ALL properties for RecordId and Record types (sys_id references).
+        // RecordId: getValue() = sys_id, getTable() = table name.
+        // Record:   getId().getValue() = sys_id; table resolved via allNodes lookup.
+        //           Used by SDK for cross-artifact references like flow_designer_flow on CatalogItem.
         for (const [key, val] of Object.entries(props)) {
-            // Added: Handle arrays of RecordId (e.g., roles: [role1, role2]) to create multiple edges
             if (Array.isArray(val)) {
                 val.forEach((item) => {
                     if (item && item.constructor?.name === 'RecordId') {
                         const targetId = item.getValue?.()?.toString();
                         const targetTable = item.getTable?.()?.toString();
-                        if (targetId && targetTable !== 'sys_db_object') {
+                        if (targetId && registry.getPluginName(targetTable) !== 'TablePlugin') {
                             edges.push({
                                 from: fromId,
                                 to: targetId,
@@ -86,7 +87,7 @@ function extractReferenceEdges(records, allNodes) {
             else if (val && val.constructor?.name === 'RecordId') {
                 const targetId = val.getValue?.()?.toString();
                 const targetTable = val.getTable?.()?.toString();
-                if (targetId && targetTable !== 'sys_db_object') {
+                if (targetId && registry.getPluginName(targetTable) !== 'TablePlugin') {
                     edges.push({
                         from: fromId,
                         to: targetId,
@@ -96,6 +97,21 @@ function extractReferenceEdges(records, allNodes) {
                     });
                 }
             }
+            else if (val && val.constructor?.name === 'Record') {
+                const targetId = val.getId?.()?.getValue?.()?.toString();
+                if (targetId) {
+                    const targetNode = allNodes.find(n => n.id === targetId);
+                    if (targetNode && registry.getPluginName(targetNode.table) !== 'TablePlugin') {
+                        edges.push({
+                            from: fromId,
+                            to: targetId,
+                            via: key,
+                            type: 'dependency',
+                            targetTable: targetNode.table
+                        });
+                    }
+                }
+            }
         }
     }
     return edges;

package/dist/extractor/index.d.ts

@@ -1,2 +1,3 @@
 import type { LineageGraph } from '../types/graphs';
-export declare function extractLineageGraph(project: any): Promise<LineageGraph>;
+import type { ArtifactTypeRegistry } from '../sdk/registry';
+export declare function extractLineageGraph(project: any, registry: ArtifactTypeRegistry): Promise<LineageGraph>;

package/dist/extractor/index.js

@@ -4,14 +4,14 @@ exports.extractLineageGraph = extractLineageGraph;
 const nodes_1 = require("./nodes");
 const edges_1 = require("./edges");
 const metadata_1 = require("./metadata");
-async function extractLineageGraph(project) {
+async function extractLineageGraph(project, registry) {
     // Get raw records from the ServiceNow SDK Project
     const records = await project.getRecords();
     const rootDir = project.getRootDir();
     // 1. Extract Nodes (Includes dynamic attributes like order, when, active)
     const nodes = (0, nodes_1.extractNodes)(records, rootDir);
     // 2. Extract Edges (Requires node list for implicit string-to-table resolution)
-    const referenceEdges = (0, edges_1.extractReferenceEdges)(records, nodes);
+    const referenceEdges = (0, edges_1.extractReferenceEdges)(records, nodes, registry);
     const compositionEdges = (0, edges_1.extractCompositionEdges)(records);
     const edges = [...referenceEdges, ...compositionEdges];
     // 3. Generate Summary Metadata

package/dist/graph/extractor.d.ts

@@ -1,6 +1,7 @@
+import { ArtifactTypeRegistry } from '../sdk/registry';
 import type { LineageGraph } from '../types/graphs';
 /**
  * The Orchestrator: Converts raw SDK records into a formal Directed Graph.
  * It treats every artifact as a node and every relationship as an iterable edge.
  */
-export declare function extractLineageGraph(project: any): Promise<LineageGraph>;
+export declare function extractLineageGraph(project: any, registry?: ArtifactTypeRegistry): Promise<LineageGraph>;

package/dist/graph/extractor.js

@@ -4,13 +4,15 @@ exports.extractLineageGraph = extractLineageGraph;
 const nodes_1 = require("../extractor/nodes");
 const edges_1 = require("../extractor/edges");
 const metadata_1 = require("../extractor/metadata");
+const registry_1 = require("../sdk/registry");
 /**
  * The Orchestrator: Converts raw SDK records into a formal Directed Graph.
  * It treats every artifact as a node and every relationship as an iterable edge.
  */
-async function extractLineageGraph(project) {
+async function extractLineageGraph(project, registry) {
     const records = project.getRecords();
     const projectRoot = project.getRootDir();
+    const reg = registry ?? new registry_1.ArtifactTypeRegistry();
     // 1. PHASE ONE: Vertex Extraction (Nodes)
     // We only extract the "winning" records to avoid conflict noise.
     // This creates the list of local artifacts.
@@ -20,7 +22,7 @@ async function extractLineageGraph(project) {
     // This allows the edge extractor to differentiate between:
     // a) A reference to a local table (e.g. x_1566039_seventh_account)
     // b) A reference to a platform table (e.g. platform:incident)
-    const refEdges = (0, edges_1.extractReferenceEdges)(records, nodes);
+    const refEdges = (0, edges_1.extractReferenceEdges)(records, nodes, reg);
     const compEdges = (0, edges_1.extractCompositionEdges)(records);
     const allEdges = [...refEdges, ...compEdges];
     // 3. PHASE THREE: Metadata & Context

package/dist/sdk/loader.d.ts

@@ -1,5 +1,7 @@
+import { ArtifactTypeRegistry } from './registry';
 export interface WorkspaceSDK {
     buildCore: any;
     sdkapi: any;
+    registry: ArtifactTypeRegistry;
 }
 export declare function loadWorkspaceSDK(sdkPath: string): WorkspaceSDK;

package/dist/sdk/loader.js

@@ -6,10 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadWorkspaceSDK = loadWorkspaceSDK;
 const module_1 = require("module");
 const path_1 = __importDefault(require("path"));
+const registry_1 = require("./registry");
 function loadWorkspaceSDK(sdkPath) {
     const requireFromWorkspace = (0, module_1.createRequire)(path_1.default.join(sdkPath, 'package.json'));
+    const registry = new registry_1.ArtifactTypeRegistry();
+    registry.load(sdkPath);
     return {
         buildCore: requireFromWorkspace('@servicenow/sdk-build-core'),
         sdkapi: requireFromWorkspace('@servicenow/sdk-api'),
+        registry,
     };
 }

package/dist/sdk/registry.d.ts

@@ -0,0 +1,30 @@
+interface TableInfo {
+    table: string;
+    pluginName: string;
+    isChild: boolean;
+    parentTable?: string;
+    parentVia?: string;
+    children: string[];
+}
+export declare class ArtifactTypeRegistry {
+    private tables;
+    load(sdkPath: string): void;
+    private register;
+    /**
+     * Parse the top-level relationships map:
+     * { parentTable: { childTable: { via, descendant, relationships: { grandchild: ... } } } }
+     */
+    private parseRelationships;
+    private processChildren;
+    get(table: string): TableInfo | undefined;
+    getPluginName(table: string): string;
+    getDisplayGroupName(table: string): string;
+    isChild(table: string): boolean;
+    getParentTable(table: string): string | undefined;
+    getChildren(table: string): string[];
+    getTablesByPlugin(pluginName: string): string[];
+    getAllPluginNames(): string[];
+    getAllTables(): string[];
+    isKnown(table: string): boolean;
+}
+export {};

package/dist/sdk/registry.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArtifactTypeRegistry = void 0;
+const module_1 = require("module");
+const path_1 = __importDefault(require("path"));
+class ArtifactTypeRegistry {
+    constructor() {
+        this.tables = new Map();
+    }
+    load(sdkPath) {
+        try {
+            const requireFromWorkspace = (0, module_1.createRequire)(path_1.default.join(sdkPath, 'package.json'));
+            const buildPlugins = requireFromWorkspace('@servicenow/sdk-build-plugins');
+            for (const [, value] of Object.entries(buildPlugins)) {
+                const plugin = value;
+                if (!plugin?.config?.name)
+                    continue;
+                const pluginName = plugin.config.name;
+                const tables = Object.keys(plugin.config.records || {}).filter(k => k !== '*');
+                if (tables.length === 0)
+                    continue;
+                for (const table of tables) {
+                    this.register(table, pluginName);
+                }
+                try {
+                    const rels = plugin.getRelationships();
+                    if (rels && typeof rels === 'object') {
+                        this.parseRelationships(rels, pluginName);
+                    }
+                }
+                catch {
+                    // safe to skip — needs compiler context
+                }
+            }
+        }
+        catch {
+            // sdk-build-plugins unavailable; registry stays empty, fallback behavior applies
+        }
+    }
+    register(table, pluginName) {
+        if (!this.tables.has(table)) {
+            this.tables.set(table, { table, pluginName, isChild: false, children: [] });
+        }
+    }
+    /**
+     * Parse the top-level relationships map:
+     * { parentTable: { childTable: { via, descendant, relationships: { grandchild: ... } } } }
+     */
+    parseRelationships(rels, pluginName) {
+        for (const [parentTable, childDefs] of Object.entries(rels)) {
+            this.register(parentTable, pluginName);
+            if (childDefs && typeof childDefs === 'object') {
+                this.processChildren(childDefs, pluginName, parentTable);
+            }
+        }
+    }
+    processChildren(childDefs, pluginName, parentTable) {
+        for (const [key, def] of Object.entries(childDefs)) {
+            // Skip meta-keys and self-referential entries
+            if (key === 'via' || key === 'descendant' || key === 'relationships')
+                continue;
+            if (key === parentTable)
+                continue;
+            const childTable = key;
+            this.register(childTable, pluginName);
+            const entry = this.tables.get(childTable);
+            if (!entry.isChild) {
+                entry.isChild = true;
+                entry.parentTable = parentTable;
+                if (def && typeof def === 'object' && typeof def.via === 'string') {
+                    entry.parentVia = def.via;
+                }
+            }
+            // Add to parent's children list
+            const parentEntry = this.tables.get(parentTable);
+            if (parentEntry && !parentEntry.children.includes(childTable)) {
+                parentEntry.children.push(childTable);
+            }
+            // Recurse into nested relationships
+            if (def && typeof def === 'object' && def.relationships && typeof def.relationships === 'object') {
+                this.processChildren(def.relationships, pluginName, childTable);
+            }
+        }
+    }
+    get(table) {
+        return this.tables.get(table);
+    }
+    getPluginName(table) {
+        return this.tables.get(table)?.pluginName ?? 'Record';
+    }
+    getDisplayGroupName(table) {
+        const entry = this.tables.get(table);
+        if (!entry)
+            return 'Other';
+        return entry.pluginName
+            .replace(/Plugin$/, '')
+            .replace(/([a-z])([A-Z])/g, '$1 $2')
+            .replace(/^./, c => c.toUpperCase())
+            .trim();
+    }
+    isChild(table) {
+        return this.tables.get(table)?.isChild ?? false;
+    }
+    getParentTable(table) {
+        return this.tables.get(table)?.parentTable;
+    }
+    getChildren(table) {
+        return this.tables.get(table)?.children ?? [];
+    }
+    getTablesByPlugin(pluginName) {
+        return [...this.tables.values()]
+            .filter(t => t.pluginName === pluginName)
+            .map(t => t.table);
+    }
+    getAllPluginNames() {
+        return [...new Set([...this.tables.values()].map(t => t.pluginName))].sort();
+    }
+    getAllTables() {
+        return [...this.tables.keys()];
+    }
+    isKnown(table) {
+        return this.tables.has(table);
+    }
+}
+exports.ArtifactTypeRegistry = ArtifactTypeRegistry;