cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/method-extractors/configs/typescript-javascript.js

@@ -0,0 +1,341 @@
+"use strict";
+// cgraph/src/core/ingestion/method-extractors/configs/typescript-javascript.ts
+// Verified against tree-sitter-typescript ^0.23.2, tree-sitter-javascript ^0.23.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javascriptMethodConfig = exports.typescriptMethodConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const helpers_js_1 = require("../../field-extractors/configs/helpers.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+// ---------------------------------------------------------------------------
+// TS/JS helpers
+// ---------------------------------------------------------------------------
+const VISIBILITY_KEYWORDS = new Set(['public', 'private', 'protected']);
+/**
+ * Extract parameters from formal_parameters.
+ *
+ * Handles both TS node types (required_parameter, optional_parameter, rest_parameter)
+ * and JS node types (identifier, assignment_pattern, rest_pattern), plus destructured
+ * parameters (object_pattern, array_pattern) in both grammars.
+ */
+function extractTsJsParameters(node) {
+    const paramList = node.childForFieldName('parameters');
+    if (!paramList)
+        return [];
+    const params = [];
+    for (let i = 0; i < paramList.namedChildCount; i++) {
+        const param = paramList.namedChild(i);
+        if (!param)
+            continue;
+        switch (param.type) {
+            case 'required_parameter': {
+                const patternNode = param.childForFieldName('pattern');
+                if (!patternNode)
+                    break;
+                // Skip TS `this` parameter — it's a compile-time type constraint, not a real param
+                if (patternNode.type === 'this')
+                    break;
+                // Rest parameter: pattern is a rest_pattern (...args) — extract inner identifier
+                const isRest = patternNode.type === 'rest_pattern';
+                const nameNode = isRest ? patternNode.firstNamedChild : patternNode;
+                if (!nameNode)
+                    break;
+                // type field is a type_annotation — unwrap to get the inner type node
+                const typeAnnotation = param.childForFieldName('type');
+                const typeNode = typeAnnotation?.firstNamedChild;
+                // Default value: presence of a 'value' field means isOptional
+                const hasDefault = !!param.childForFieldName('value');
+                params.push({
+                    name: nameNode.text,
+                    type: typeNode
+                        ? ((0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim() ?? null)
+                        : null,
+                    rawType: typeNode?.text?.trim() ?? null,
+                    isOptional: hasDefault,
+                    isVariadic: isRest,
+                });
+                break;
+            }
+            case 'optional_parameter': {
+                const nameNode = param.childForFieldName('pattern');
+                if (!nameNode)
+                    break;
+                const typeAnnotation = param.childForFieldName('type');
+                const typeNode = typeAnnotation?.firstNamedChild;
+                params.push({
+                    name: nameNode.text,
+                    type: typeNode
+                        ? ((0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim() ?? null)
+                        : null,
+                    rawType: typeNode?.text?.trim() ?? null,
+                    isOptional: true,
+                    isVariadic: false,
+                });
+                break;
+            }
+            case 'rest_parameter': {
+                const nameNode = param.childForFieldName('pattern');
+                if (!nameNode)
+                    break;
+                const typeAnnotation = param.childForFieldName('type');
+                const typeNode = typeAnnotation?.firstNamedChild;
+                params.push({
+                    name: nameNode.text,
+                    type: typeNode
+                        ? ((0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim() ?? null)
+                        : null,
+                    rawType: typeNode?.text?.trim() ?? null,
+                    isOptional: false,
+                    isVariadic: true,
+                });
+                break;
+            }
+            case 'identifier': {
+                // JS: bare parameter name, no type info
+                params.push({
+                    name: param.text,
+                    type: null,
+                    rawType: null,
+                    isOptional: false,
+                    isVariadic: false,
+                });
+                break;
+            }
+            case 'assignment_pattern': {
+                // JS: param = defaultValue — the left side is the name, isOptional = true
+                const left = param.childForFieldName('left');
+                if (left) {
+                    params.push({
+                        name: left.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: true,
+                        isVariadic: false,
+                    });
+                }
+                break;
+            }
+            case 'rest_pattern': {
+                // JS: ...args
+                const inner = param.firstNamedChild;
+                if (inner) {
+                    params.push({
+                        name: inner.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: false,
+                        isVariadic: true,
+                    });
+                }
+                break;
+            }
+            case 'object_pattern':
+            case 'array_pattern': {
+                // Destructured parameter — use full text as name
+                params.push({
+                    name: param.text,
+                    type: null,
+                    rawType: null,
+                    isOptional: false,
+                    isVariadic: false,
+                });
+                break;
+            }
+        }
+    }
+    return params;
+}
+/** Regex to extract @returns or @return from JSDoc comments: `@returns {Type}` */
+const JSDOC_RETURN_RE = /@returns?\s*\{([^}]+)\}/;
+/**
+ * Minimal sanitization for JSDoc return types — preserves generic wrappers
+ * (e.g. `Promise<User>`) so that extractReturnTypeName in call-processor
+ * can apply WRAPPER_GENERICS unwrapping. Only strips JSDoc-specific syntax markers.
+ */
+function sanitizeJsDocReturnType(raw) {
+    let type = raw.trim();
+    // Strip JSDoc nullable/non-nullable prefixes: ?User → User, !User → User
+    if (type.startsWith('?') || type.startsWith('!'))
+        type = type.slice(1);
+    // Strip module: prefix — module:models.User → models.User
+    if (type.startsWith('module:'))
+        type = type.slice(7);
+    // Reject unions (ambiguous)
+    if (type.includes('|'))
+        return undefined;
+    if (!type)
+        return undefined;
+    return type;
+}
+/**
+ * Walk backwards through preceding siblings looking for a JSDoc comment containing
+ * `@returns {Type}` or `@return {Type}`. Stops at the first non-comment named node
+ * (excluding decorators, which precede methods in TS/JS).
+ */
+function extractJsDocReturnType(node) {
+    let sibling = node.previousSibling;
+    while (sibling) {
+        if (sibling.type === 'comment') {
+            const match = JSDOC_RETURN_RE.exec(sibling.text);
+            if (match)
+                return sanitizeJsDocReturnType(match[1]);
+        }
+        else if (sibling.isNamed && sibling.type !== 'decorator')
+            break;
+        sibling = sibling.previousSibling;
+    }
+    return undefined;
+}
+/**
+ * Extract return type from return_type field, unwrapping type_annotation.
+ * Falls back to JSDoc `@returns {Type}` when the AST has no return type annotation.
+ *
+ * tree-sitter-typescript uses `return_type` as the field name (not `type` like JVM).
+ * The return_type field points to a type_annotation node that must be unwrapped.
+ */
+function extractTsJsReturnType(node) {
+    const returnType = node.childForFieldName('return_type');
+    if (returnType) {
+        if (returnType.type === 'type_annotation') {
+            const inner = returnType.firstNamedChild;
+            if (inner)
+                return inner.text?.trim();
+        }
+        return returnType.text?.trim();
+    }
+    // AST has no return type annotation — try JSDoc fallback
+    return extractJsDocReturnType(node);
+}
+/**
+ * Extract visibility from accessibility_modifier or #private name.
+ *
+ * tree-sitter-typescript emits accessibility_modifier as a named child of method nodes
+ * (not as a modifiers wrapper like JVM). Pass 1 scans for that child; pass 2 checks for
+ * ES2022 private_property_identifier (#name). Default: public.
+ */
+function extractTsJsVisibility(node) {
+    // Pass 1: check for accessibility_modifier named child (TS-specific)
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === 'accessibility_modifier') {
+            const t = child.text.trim();
+            if (VISIBILITY_KEYWORDS.has(t))
+                return t;
+        }
+    }
+    // Pass 2: ES2022 private methods (#name) are inherently private
+    const nameNode = node.childForFieldName('name');
+    if (nameNode && nameNode.type === 'private_property_identifier')
+        return 'private';
+    // No accessibility_modifier found — default to public.
+    // Note: tree-sitter-typescript does not wrap modifiers in a 'modifiers' node
+    // (unlike JVM), so there is no wrapper to scan.
+    return 'public';
+}
+/**
+ * Extract decorator names, prefixed with '@'.
+ *
+ * In tree-sitter-typescript, decorators are **siblings** of the method_definition in the
+ * class_body — they are NOT children of the method node. We find them by walking backwards
+ * from the method node through its preceding siblings in the parent body.
+ */
+function extractTsJsDecorators(node) {
+    const decorators = [];
+    // Walk backwards via previousNamedSibling to collect consecutive decorator siblings.
+    // This avoids the O(N) index-finding scan through the parent's children.
+    let sibling = node.previousNamedSibling;
+    while (sibling && sibling.type === 'decorator') {
+        const name = extractDecoratorName(sibling);
+        if (name)
+            decorators.unshift(name);
+        sibling = sibling.previousNamedSibling;
+    }
+    return decorators;
+}
+function extractDecoratorName(decorator) {
+    const expr = decorator.firstNamedChild;
+    if (!expr)
+        return undefined;
+    if (expr.type === 'call_expression') {
+        const fn = expr.childForFieldName('function');
+        return fn ? '@' + fn.text : undefined;
+    }
+    if (expr.type === 'identifier')
+        return '@' + expr.text;
+    if (expr.type === 'member_expression')
+        return '@' + expr.text;
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+// TS and JS share the same config base. TS-only node types (abstract_class_declaration,
+// interface_declaration, abstract_method_signature, method_signature, interface_body) are
+// included because the JS grammar never produces these nodes — they are harmless no-ops.
+// This mirrors the field extractor's typescript-javascript.ts shared pattern.
+//
+// Note: TS and JS share a method config but NOT a field extractor because the TS field
+// extractor needs a hand-written class for type_alias_declaration object literals and
+// nested type discovery. Methods have no such requirement.
+const shared = {
+    typeDeclarationNodes: [
+        'class_declaration',
+        'abstract_class_declaration',
+        'interface_declaration',
+    ],
+    // Note: TS constructors are method_definition nodes (name = 'constructor'), so no
+    // explicit constructor_declaration entry is needed (unlike JVM/C# configs).
+    // Known gaps:
+    //   - call_signature and construct_signature (e.g., interface Fn { (x: string): void; })
+    //     are not extracted — they have no name field and are uncommon in practice.
+    //   - class_expression (const Foo = class { ... }) — methods inside class expressions
+    //     are not discovered because class_expression is not in typeDeclarationNodes.
+    //   - declare module / declare global augmentations — methods inside ambient_module_declaration
+    //     wrappers are not surfaced because the top-level walker doesn't descend into them.
+    methodNodeTypes: [
+        'method_definition',
+        'method_signature',
+        'abstract_method_signature',
+        'function_declaration',
+        'generator_function_declaration',
+        'function_signature',
+    ],
+    bodyNodeTypes: ['class_body', 'interface_body'],
+    extractName(node) {
+        const nameNode = node.childForFieldName('name');
+        return nameNode?.text;
+    },
+    extractReturnType: extractTsJsReturnType,
+    extractParameters: extractTsJsParameters,
+    extractVisibility: extractTsJsVisibility,
+    isStatic(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'static');
+    },
+    isAbstract(node, ownerNode) {
+        // Explicit abstract keyword on the method itself
+        if ((0, helpers_js_1.hasKeyword)(node, 'abstract'))
+            return true;
+        // Interface methods are implicitly abstract — TS interfaces never have method bodies
+        // (unlike Java default methods), so no !body check needed
+        if (ownerNode.type === 'interface_declaration')
+            return true;
+        return false;
+    },
+    isFinal(_node) {
+        return false; // TS/JS has no final/sealed methods
+    },
+    extractAnnotations: extractTsJsDecorators,
+    isAsync(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'async');
+    },
+    isOverride(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'override');
+    },
+};
+exports.typescriptMethodConfig = {
+    ...shared,
+    language: index_js_1.SupportedLanguages.TypeScript,
+};
+exports.javascriptMethodConfig = {
+    ...shared,
+    language: index_js_1.SupportedLanguages.JavaScript,
+};

package/dist/core/code/engine/core/ingestion/method-extractors/generic.js

@@ -0,0 +1,209 @@
+"use strict";
+// cgraph/src/core/ingestion/method-extractors/generic.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMethodExtractor = createMethodExtractor;
+const logger_js_1 = require("../../logger.js");
+/**
+ * Node types that imply static member semantics when they appear as the owner
+ * of a method (Kotlin companion objects, Kotlin top-level `object` declarations,
+ * Ruby `class << self` singleton classes). A config that lists any of these in
+ * `typeDeclarationNodes` MUST also include the same node type in
+ * `staticOwnerTypes` — otherwise methods inside these containers silently get
+ * `isStatic=false`, which is a correctness bug that previously only surfaced
+ * at analysis time on large repos.
+ *
+ * Opt-out: a config that sets `staticOwnerTypes: new Set()` (explicit empty
+ * set) signals "I handle static-ness entirely via isStatic()" and is exempt
+ * from the guard.
+ */
+const STATIC_IMPLYING_OWNER_TYPES = new Set([
+    'companion_object',
+    'object_declaration',
+    'singleton_class',
+]);
+/**
+ * Create a MethodExtractor from a declarative config.
+ *
+ * @throws {Error} if `typeDeclarationNodes` contains a static-implying owner
+ *   type (companion_object / object_declaration / singleton_class) that is
+ *   not covered by `staticOwnerTypes`. The guard fires once per language at
+ *   provider construction to prevent silent `isStatic=false` regressions. See
+ *   `STATIC_IMPLYING_OWNER_TYPES` for the exact opt-out convention.
+ */
+function createMethodExtractor(config) {
+    // Runtime invariant: each static-implying container type declared in
+    // typeDeclarationNodes must be covered by staticOwnerTypes. An explicit
+    // empty Set is treated as intentional opt-out.
+    if (config.staticOwnerTypes === undefined) {
+        const missing = config.typeDeclarationNodes.filter((t) => STATIC_IMPLYING_OWNER_TYPES.has(t));
+        if (missing.length > 0) {
+            throw new Error(`[MethodExtractionConfig:${config.language}] typeDeclarationNodes includes static-implying owner type(s) ` +
+                `${JSON.stringify(missing)} but staticOwnerTypes is not set. Add ` +
+                `'staticOwnerTypes: new Set([${missing.map((t) => `'${t}'`).join(', ')}])' ` +
+                `to the config, or set 'staticOwnerTypes: new Set()' to opt out explicitly.`);
+        }
+    }
+    else {
+        const missing = config.typeDeclarationNodes.filter((t) => STATIC_IMPLYING_OWNER_TYPES.has(t) && !config.staticOwnerTypes.has(t));
+        // Explicit empty Set is the opt-out signal; don't second-guess it.
+        if (missing.length > 0 && config.staticOwnerTypes.size > 0) {
+            throw new Error(`[MethodExtractionConfig:${config.language}] typeDeclarationNodes includes static-implying owner type(s) ` +
+                `${JSON.stringify(missing)} that are missing from staticOwnerTypes. ` +
+                `Either add them to staticOwnerTypes, or set 'staticOwnerTypes: new Set()' to opt out explicitly.`);
+        }
+    }
+    const typeDeclarationSet = new Set(config.typeDeclarationNodes);
+    const methodNodeSet = new Set(config.methodNodeTypes);
+    const bodyNodeSet = new Set(config.bodyNodeTypes);
+    return {
+        language: config.language,
+        isTypeDeclaration(node) {
+            return typeDeclarationSet.has(node.type);
+        },
+        extract(node, context) {
+            if (!typeDeclarationSet.has(node.type))
+                return null;
+            // Resolve owner name: config hook → field-based → type_identifier → simple_identifier → "Companion"
+            let ownerName;
+            if (config.extractOwnerName) {
+                ownerName = config.extractOwnerName(node);
+            }
+            if (!ownerName) {
+                const nameField = node.childForFieldName('name');
+                if (nameField) {
+                    ownerName = nameField.text;
+                }
+                else {
+                    for (let i = 0; i < node.namedChildCount; i++) {
+                        const child = node.namedChild(i);
+                        if (child &&
+                            (child.type === 'type_identifier' ||
+                                child.type === 'simple_identifier' ||
+                                child.type === 'identifier')) {
+                            ownerName = child.text;
+                            break;
+                        }
+                    }
+                }
+            }
+            // Unnamed companion objects use "Companion" (Kotlin convention)
+            if (!ownerName && node.type === 'companion_object') {
+                ownerName = 'Companion';
+            }
+            if (!ownerName)
+                return null;
+            const methods = [];
+            const bodies = findBodies(node, bodyNodeSet);
+            for (const body of bodies) {
+                extractMethodsFromBody(body, node, context, config, methodNodeSet, methods);
+            }
+            // Extract primary constructor from the owner node itself (e.g. C# 12)
+            if (config.extractPrimaryConstructor) {
+                const primaryCtor = config.extractPrimaryConstructor(node, context);
+                if (primaryCtor)
+                    methods.push(primaryCtor);
+            }
+            return { ownerName, methods };
+        },
+        extractFromNode(node, context) {
+            if (!methodNodeSet.has(node.type))
+                return null;
+            return buildMethod(node, node, context, config);
+        },
+        ...(config.extractFunctionName ? { extractFunctionName: config.extractFunctionName } : {}),
+    };
+}
+function findBodies(node, bodyNodeSet) {
+    const result = [];
+    const bodyField = node.childForFieldName('body');
+    if (bodyField && bodyNodeSet.has(bodyField.type)) {
+        result.push(bodyField);
+        addNestedBodies(bodyField, bodyNodeSet, result);
+        return result;
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && bodyNodeSet.has(child.type)) {
+            result.push(child);
+        }
+    }
+    if (result.length === 0 && bodyField) {
+        // Fallback: body field exists but its type is not in bodyNodeTypes.
+        // This may indicate a config typo — log for debugging if NODE_ENV is development.
+        if (process.env.NODE_ENV === 'development') {
+            logger_js_1.logger.warn(`[MethodExtractor] body field type '${bodyField.type}' not in bodyNodeTypes for node '${node.type}'`);
+        }
+        result.push(bodyField);
+        addNestedBodies(bodyField, bodyNodeSet, result);
+    }
+    return result;
+}
+function addNestedBodies(parent, bodyNodeSet, out, seen) {
+    const visited = seen ?? new Set(out);
+    for (let i = 0; i < parent.namedChildCount; i++) {
+        const child = parent.namedChild(i);
+        if (child && bodyNodeSet.has(child.type) && !visited.has(child)) {
+            visited.add(child);
+            out.push(child);
+        }
+    }
+}
+function extractMethodsFromBody(body, ownerNode, context, config, methodNodeSet, out) {
+    for (let i = 0; i < body.namedChildCount; i++) {
+        let child = body.namedChild(i);
+        if (!child)
+            continue;
+        // C++ template methods are wrapped in template_declaration — unwrap to the inner node
+        if (child.type === 'template_declaration') {
+            const inner = child.namedChildren.find((c) => methodNodeSet.has(c.type));
+            if (inner)
+                child = inner;
+        }
+        if (methodNodeSet.has(child.type)) {
+            const method = buildMethod(child, ownerNode, context, config);
+            if (method)
+                out.push(method);
+        }
+        // Recurse into enum constant anonymous class bodies
+        if (child.type === 'enum_constant') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const innerBody = child.namedChild(j);
+                if (innerBody && innerBody.type === 'class_body') {
+                    extractMethodsFromBody(innerBody, ownerNode, context, config, methodNodeSet, out);
+                }
+            }
+        }
+    }
+}
+function buildMethod(node, ownerNode, context, config) {
+    const name = config.extractName(node);
+    if (!name)
+        return null;
+    const isAbstract = config.isAbstract(node, ownerNode);
+    let isFinal = config.isFinal(node);
+    // Domain invariant: abstract methods cannot be final
+    if (isAbstract)
+        isFinal = false;
+    // Static-owner detection is config-driven: each language declares which
+    // container node types imply static (e.g. Ruby singleton_class, Kotlin companion_object).
+    const isStatic = (config.staticOwnerTypes?.has(ownerNode.type) ?? false) || config.isStatic(node);
+    return {
+        name,
+        receiverType: config.extractReceiverType?.(node) ?? null,
+        returnType: config.extractReturnType(node) ?? null,
+        parameters: config.extractParameters(node),
+        visibility: config.extractVisibility(node),
+        isStatic,
+        isAbstract,
+        isFinal,
+        ...(config.isVirtual?.(node) ? { isVirtual: true } : {}),
+        ...(config.isOverride?.(node) ? { isOverride: true } : {}),
+        ...(config.isAsync?.(node) ? { isAsync: true } : {}),
+        ...(config.isPartial?.(node) ? { isPartial: true } : {}),
+        ...(config.isConst?.(node) ? { isConst: true } : {}),
+        ...(config.isDeleted?.(node) ? { isDeleted: true } : {}),
+        annotations: config.extractAnnotations?.(node) ?? [],
+        sourceFile: context.filePath,
+        line: node.startPosition.row + 1,
+    };
+}

package/dist/core/code/engine/core/ingestion/method-types.js

@@ -0,0 +1,3 @@
+"use strict";
+// cgraph/src/core/ingestion/method-types.ts
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/code/engine/core/ingestion/model/field-registry.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Field Registry
+ *
+ * Owner-scoped field/property index extracted from SymbolTable.
+ * Stores Property / Variable / Const / Static symbols keyed by
+ * `ownerNodeId\0fieldName` for O(1) lookup. Supports multiple defs
+ * under the same (owner, name) — e.g. legacy Property plus a
+ * scope-resolution Variable reconciliation entry.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFieldRegistry = void 0;
+const EMPTY = Object.freeze([]);
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+const createFieldRegistry = () => {
+    const fieldByOwner = new Map();
+    const lookupAllByOwner = (ownerNodeId, fieldName) => {
+        return fieldByOwner.get(`${ownerNodeId}\0${fieldName}`) ?? EMPTY;
+    };
+    const lookupFieldByOwner = (ownerNodeId, fieldName) => {
+        const pool = lookupAllByOwner(ownerNodeId, fieldName);
+        return pool.length === 0 ? undefined : pool[0];
+    };
+    const register = (ownerNodeId, fieldName, def) => {
+        const key = `${ownerNodeId}\0${fieldName}`;
+        const existing = fieldByOwner.get(key);
+        if (existing) {
+            existing.push(def);
+        }
+        else {
+            fieldByOwner.set(key, [def]);
+        }
+    };
+    const clear = () => {
+        fieldByOwner.clear();
+    };
+    return { lookupFieldByOwner, lookupAllByOwner, register, clear };
+};
+exports.createFieldRegistry = createFieldRegistry;

package/dist/core/code/engine/core/ingestion/model/index.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Semantic Model — public module surface.
+ *
+ * Barrel re-export for the `model/` module. Consumers outside `model/`
+ * should import from this file rather than reaching into individual
+ * registry files.
+ *
+ * The model is owner-scoped type/method/field knowledge layered above
+ * `SymbolTable`. File-indexed and name-keyed callable lookups stay in
+ * `SymbolTable` by design.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_NODE_LABELS = exports.DISPATCH_LABELS = exports.INERT_LABELS = exports.CALLABLE_ONLY_LABELS = exports.createFieldRegistry = exports.createMethodRegistry = exports.createTypeRegistry = exports.CALL_TARGET_TYPES = exports.FREE_CALLABLE_TUPLE = exports.FREE_CALLABLE_TYPES = exports.CLASS_TYPES_TUPLE = exports.CLASS_TYPES = exports.createSymbolTable = exports.createSemanticModel = void 0;
+// Unified semantic model (factory + interfaces). SemanticModel is the
+// top-level container and owns the file/callable SymbolTable as a
+// nested `symbols` field.
+var semantic_model_js_1 = require("./semantic-model.js");
+Object.defineProperty(exports, "createSemanticModel", { enumerable: true, get: function () { return semantic_model_js_1.createSemanticModel; } });
+// SymbolTable is exclusively owned by SemanticModel. Re-exported here
+// for the rare caller that needs the file/callable interface in
+// isolation (e.g. tests).
+var symbol_table_js_1 = require("./symbol-table.js");
+Object.defineProperty(exports, "createSymbolTable", { enumerable: true, get: function () { return symbol_table_js_1.createSymbolTable; } });
+Object.defineProperty(exports, "CLASS_TYPES", { enumerable: true, get: function () { return symbol_table_js_1.CLASS_TYPES; } });
+Object.defineProperty(exports, "CLASS_TYPES_TUPLE", { enumerable: true, get: function () { return symbol_table_js_1.CLASS_TYPES_TUPLE; } });
+Object.defineProperty(exports, "FREE_CALLABLE_TYPES", { enumerable: true, get: function () { return symbol_table_js_1.FREE_CALLABLE_TYPES; } });
+Object.defineProperty(exports, "FREE_CALLABLE_TUPLE", { enumerable: true, get: function () { return symbol_table_js_1.FREE_CALLABLE_TUPLE; } });
+Object.defineProperty(exports, "CALL_TARGET_TYPES", { enumerable: true, get: function () { return symbol_table_js_1.CALL_TARGET_TYPES; } });
+// `SymbolDefinition` moved to `cgraph-shared` (RFC #909 Ring 1 #910).
+// Consumers should import it directly from `cgraph-shared`, not via this barrel.
+// Type registry (classes, structs, interfaces, enums, records, impls)
+var type_registry_js_1 = require("./type-registry.js");
+Object.defineProperty(exports, "createTypeRegistry", { enumerable: true, get: function () { return type_registry_js_1.createTypeRegistry; } });
+// Method registry (owner-scoped methods with arity-aware overload lookup)
+var method_registry_js_1 = require("./method-registry.js");
+Object.defineProperty(exports, "createMethodRegistry", { enumerable: true, get: function () { return method_registry_js_1.createMethodRegistry; } });
+// Field registry (owner-scoped fields/properties)
+var field_registry_js_1 = require("./field-registry.js");
+Object.defineProperty(exports, "createFieldRegistry", { enumerable: true, get: function () { return field_registry_js_1.createFieldRegistry; } });
+// Behavior-grouped dispatch table for SymbolTable.add() routing.
+// See registration-table.ts module JSDoc for the behavior group taxonomy
+// and "how to add a new NodeLabel" checklist.
+// NOTE: createRegistrationTable, RegistrationHook, and RegistrationTableDeps
+// are deliberately NOT re-exported here — they are factory internals of
+// SemanticModel and should only be imported directly from registration-table.js
+// by semantic-model.ts and the registration-table.test.ts file.
+var registration_table_js_1 = require("./registration-table.js");
+Object.defineProperty(exports, "CALLABLE_ONLY_LABELS", { enumerable: true, get: function () { return registration_table_js_1.CALLABLE_ONLY_LABELS; } });
+Object.defineProperty(exports, "INERT_LABELS", { enumerable: true, get: function () { return registration_table_js_1.INERT_LABELS; } });
+Object.defineProperty(exports, "DISPATCH_LABELS", { enumerable: true, get: function () { return registration_table_js_1.DISPATCH_LABELS; } });
+Object.defineProperty(exports, "ALL_NODE_LABELS", { enumerable: true, get: function () { return registration_table_js_1.ALL_NODE_LABELS; } });