d365fo-mcp 1.6.0 → 1.7.0

package/README.md

@@ -10,7 +10,7 @@
 [![TypeScript](https://img.shields.io/badge/TypeScript-6.0-blue.svg)](https://www.typescriptlang.org/)
 [![Tests](https://img.shields.io/badge/tests-1400%2B-brightgreen.svg)](docs/TESTING.md)
 <!-- coverage-badge:start -->
-[![Core coverage](https://img.shields.io/badge/core_coverage-100%25-brightgreen.svg)](eval/COVERAGE.md) [![Total coverage](https://img.shields.io/badge/total_coverage-85.9%25-lightgrey.svg)](eval/COVERAGE.md)
+[![Core coverage](https://img.shields.io/badge/core_coverage-100%25-brightgreen.svg)](eval/COVERAGE.md) [![Total coverage](https://img.shields.io/badge/total_coverage-91%25-lightgrey.svg)](eval/COVERAGE.md)
 <!-- coverage-badge:end -->
 
 *Grounded AI development for Dynamics 365 Finance & Operations — works with GitHub Copilot and Claude Code*

package/bridge/D365MetadataBridge/Services/MetadataWriteService.cs

@@ -1504,7 +1504,7 @@ namespace D365MetadataBridge.Services
                         ?? throw new ArgumentException($"Table '{objectName}' not found");
                     var msi = GetModelSaveInfoForObject(_provider.Tables, objectName);
                     if (!SetAxTableProperty(obj, propertyPath, propertyValue))
-                        throw new ArgumentException($"Unknown AxTable property '{propertyPath}' — nothing was written. Supported: label, developerDocumentation, configurationKey, formRef, tableGroup, cacheLookup, clusteredIndex, primaryIndex, replacementKey, saveDataPerCompany, tableType, supportInheritance, instanceRelationType, extends, titleField1, titleField2.");
+                        throw new ArgumentException($"Unknown AxTable property '{propertyPath}' — nothing was written. Supported: label, developerDocumentation, configurationKey, formRef, tableGroup, cacheLookup, clusteredIndex, primaryIndex, replacementKey, saveDataPerCompany, allowRowVersionChangeTracking, createdBy, createdDateTime, createdTransactionId, modifiedBy, modifiedDateTime, modifiedTransactionId, tableType, supportInheritance, instanceRelationType, extends, titleField1, titleField2.");
                     ((IMetaTableProvider)_provider.Tables).Update(obj, msi);
                     return new { success = true, operation = "modify-property", objectType, objectName, propertyPath, propertyValue, api = "Update" };
                 }
@@ -1548,6 +1548,16 @@ namespace D365MetadataBridge.Services
                     ((IMetaViewProvider)_provider.Views).Update(obj, msi);
                     return new { success = true, operation = "modify-property", objectType, objectName, propertyPath, propertyValue, api = "Update" };
                 }
+                case "data-entity":
+                {
+                    var obj = _provider.DataEntityViews.Read(objectName)
+                        ?? throw new ArgumentException($"Data entity '{objectName}' not found");
+                    var msi = GetModelSaveInfoForObject(_provider.DataEntityViews, objectName);
+                    if (!SetAxDataEntityViewProperty(obj, propertyPath, propertyValue))
+                        throw new ArgumentException($"Unknown AxDataEntityView property '{propertyPath}' — nothing was written. Supported: label, developerDocumentation, primaryKey, isPublic, publicEntityName, publicCollectionName, dataManagementEnabled, dataManagementStagingTable, entityCategory, allowRowVersionChangeTracking, allowRetention.");
+                    ((IMetaDataEntityViewProvider)_provider.DataEntityViews).Update(obj, msi);
+                    return new { success = true, operation = "modify-property", objectType, objectName, propertyPath, propertyValue, api = "Update" };
+                }
                 case "menu-item-action":
                 {
                     var obj = _provider.MenuItemActions.Read(objectName)
@@ -2642,6 +2652,16 @@ namespace D365MetadataBridge.Services
                 case "savedatapercompany":
                     tbl.SaveDataPerCompany = ParseNoYes(value);
                     break;
+                // Dual-write's table-side change-tracking prerequisite.
+                case "allowrowversionchangetracking":
+                    tbl.AllowRowVersionChangeTracking = ParseNoYes(value);
+                    break;
+                case "createdby": tbl.CreatedBy = ParseNoYes(value); break;
+                case "createddatetime": tbl.CreatedDateTime = ParseNoYes(value); break;
+                case "createdtransactionid": tbl.CreatedTransactionId = ParseNoYes(value); break;
+                case "modifiedby": tbl.ModifiedBy = ParseNoYes(value); break;
+                case "modifieddatetime": tbl.ModifiedDateTime = ParseNoYes(value); break;
+                case "modifiedtransactionid": tbl.ModifiedTransactionId = ParseNoYes(value); break;
                 case "tabletype":
                     if (!Enum.TryParse<Microsoft.Dynamics.AX.Metadata.Core.MetaModel.TableType>(value, true, out var tt))
                         throw new ArgumentException(
@@ -2725,6 +2745,39 @@ namespace D365MetadataBridge.Services
             return true;
         }
 
+        /// <summary>
+        /// AxDataEntityView property setter. AllowRowVersionChangeTracking is
+        /// dual-write's change-tracking switch and is also required on every
+        /// source table.
+        /// </summary>
+        private bool SetAxDataEntityViewProperty(AxDataEntityView e, string prop, string value)
+        {
+            switch (prop.ToLowerInvariant())
+            {
+                case "label": e.Label = value; break;
+                case "developerdocumentation": e.DeveloperDocumentation = value; break;
+                case "primarykey": e.PrimaryKey = value; break;
+                case "publicentityname": e.PublicEntityName = value; break;
+                case "publiccollectionname": e.PublicCollectionName = value; break;
+                case "datamanagementstagingtable": e.DataManagementStagingTable = value; break;
+                case "ispublic": e.IsPublic = ParseNoYes(value); break;
+                case "datamanagementenabled": e.DataManagementEnabled = ParseNoYes(value); break;
+                case "allowrowversionchangetracking": e.AllowRowVersionChangeTracking = ParseNoYes(value); break;
+                case "allowretention": e.AllowRetention = ParseNoYes(value); break;
+                case "entitycategory":
+                    if (!Enum.TryParse<Microsoft.Dynamics.AX.Metadata.Core.MetaModel.EntityCategory>(value, true, out var ec))
+                        throw new ArgumentException(
+                            $"'{value}' is not a valid EntityCategory. Valid values: " +
+                            string.Join(", ", Enum.GetNames(typeof(Microsoft.Dynamics.AX.Metadata.Core.MetaModel.EntityCategory))) + ".");
+                    e.EntityCategory = ec;
+                    break;
+                default:
+                    Console.Error.WriteLine($"[WriteService] Unknown AxDataEntityView property: {prop}");
+                    return false;
+            }
+            return true;
+        }
+
         private bool SetAxViewProperty(AxView v, string prop, string value)
         {
             switch (prop.ToLowerInvariant())

package/dist/bridge/bridgeAdapter.js

@@ -1077,7 +1077,7 @@ const BRIDGE_MODIFY_OPS = new Set([
  */
 const BRIDGE_MODIFY_TYPES = new Set([
     'class', 'table', 'enum', 'edt',
-    'form', 'query', 'view',
+    'form', 'query', 'view', 'data-entity',
     'class-extension', 'table-extension', 'form-extension', 'enum-extension',
     'menu-item-action', 'menu-item-display', 'menu-item-output',
     'menu',

package/dist/metadata/modelDescriptor.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Model descriptor reader — `<PackagesLocalDirectory>/<Package>/Descriptor/<Model>.xml`.
+ *
+ * `<ModuleReferences>` is the only statement of what a model may see: xppc
+ * resolves types against the referenced packages, not against everything
+ * installed, so an indexed type can still be invisible to the model being
+ * compiled. The visible set is the model's own package plus its DIRECT
+ * references — walking the closure would mark such a type visible again and
+ * hide the defect this exists to catch.
+ *
+ * Not a compiler: a table in a referenced package can still need a further
+ * reference because a third package contributes a table extension to it.
+ *
+ * build_d365fo_project reads the same element to order its build queue and
+ * calls straight into `parseModuleReferences`.
+ */
+/**
+ * Extract every `<d2p1:string>` entry of a descriptor's `<ModuleReferences>`.
+ * The sibling `<ModelReferences>` is `i:nil` in every descriptor observed on a
+ * real box, so the flat scan cannot pick up entries from it.
+ */
+export declare function parseModuleReferences(descriptorXml: string): string[];
+/**
+ * Read a model's direct module references, or null when it has no readable
+ * descriptor — which callers must treat as unknown, never as "references nothing".
+ */
+export declare function readModuleReferences(packagesPath: string, modelName: string): Promise<string[] | null>;
+/** The PackagesLocalDirectory root contained in a package or workspace path. */
+export declare function packagesRootFromPath(candidate: string | undefined | null): string | null;
+export interface ModelVisibility {
+    /** Target model, for diagnostics. */
+    model: string;
+    /** PackagesLocalDirectory root the indexed file paths are relative to. */
+    packagesRoot: string;
+    /** Lower-cased package folder names the model may reference (incl. its own). */
+    visiblePackages: ReadonlySet<string>;
+    /**
+     * Package folder owning an indexed file, or null when the path is not under
+     * this packages root. Null means "cannot tell" and must silence the check.
+     */
+    packageOf(filePath: string): string | null;
+}
+/**
+ * Build (and memoise) the visibility oracle for `modelName`; null whenever the
+ * answer would be a guess. Callers must then skip the check — a missing
+ * descriptor turning into a wall of errors is worse than the gap it closes.
+ */
+export declare function getModelVisibility(packagesRoot: string | null | undefined, modelName: string | null | undefined): ModelVisibility | null;
+/** Uncached form — exported for tests, which need a fresh fixture each time. */
+export declare function buildModelVisibility(packagesRoot: string | null | undefined, modelName: string | null | undefined): ModelVisibility | null;
+/** Test seam — drops the memoised visibility oracles. */
+export declare function clearModelVisibilityCache(): void;
+//# sourceMappingURL=modelDescriptor.d.ts.map

package/dist/metadata/modelDescriptor.js

@@ -0,0 +1,129 @@
+/**
+ * Model descriptor reader — `<PackagesLocalDirectory>/<Package>/Descriptor/<Model>.xml`.
+ *
+ * `<ModuleReferences>` is the only statement of what a model may see: xppc
+ * resolves types against the referenced packages, not against everything
+ * installed, so an indexed type can still be invisible to the model being
+ * compiled. The visible set is the model's own package plus its DIRECT
+ * references — walking the closure would mark such a type visible again and
+ * hide the defect this exists to catch.
+ *
+ * Not a compiler: a table in a referenced package can still need a further
+ * reference because a third package contributes a table extension to it.
+ *
+ * build_d365fo_project reads the same element to order its build queue and
+ * calls straight into `parseModuleReferences`.
+ */
+import { readFile } from 'fs/promises';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import * as path from 'path';
+/**
+ * Extract every `<d2p1:string>` entry of a descriptor's `<ModuleReferences>`.
+ * The sibling `<ModelReferences>` is `i:nil` in every descriptor observed on a
+ * real box, so the flat scan cannot pick up entries from it.
+ */
+export function parseModuleReferences(descriptorXml) {
+    return Array.from(descriptorXml.matchAll(/<d2p1:string>\s*([^<\s]+)\s*<\/d2p1:string>/g))
+        .map(m => m[1].trim())
+        .filter(Boolean);
+}
+/**
+ * Read a model's direct module references, or null when it has no readable
+ * descriptor — which callers must treat as unknown, never as "references nothing".
+ */
+export async function readModuleReferences(packagesPath, modelName) {
+    try {
+        return parseModuleReferences(await readFile(path.join(packagesPath, modelName, 'Descriptor', `${modelName}.xml`), 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** The PackagesLocalDirectory root contained in a package or workspace path. */
+export function packagesRootFromPath(candidate) {
+    if (!candidate)
+        return null;
+    const m = /^(.+[\\/]PackagesLocalDirectory)(?:[\\/]|$)/i.exec(candidate.replace(/\//g, '\\'));
+    return m ? m[1] : null;
+}
+/**
+ * Locate `<Model>.xml`. `<root>/<Model>/Descriptor/<Model>.xml` is the common
+ * layout and costs one stat; ISV models inside a differently-named package fall
+ * back to a single bounded sweep of the root's package folders.
+ */
+function findDescriptor(packagesRoot, modelName) {
+    const direct = path.join(packagesRoot, modelName, 'Descriptor', `${modelName}.xml`);
+    if (existsSync(direct))
+        return { file: direct, pkg: modelName };
+    let entries;
+    try {
+        entries = readdirSync(packagesRoot);
+    }
+    catch {
+        return null;
+    }
+    for (const pkg of entries) {
+        const file = path.join(packagesRoot, pkg, 'Descriptor', `${modelName}.xml`);
+        if (existsSync(file))
+            return { file, pkg };
+    }
+    return null;
+}
+/** Cache key → resolved visibility (or null when it could not be resolved). */
+const visibilityCache = new Map();
+/**
+ * Build (and memoise) the visibility oracle for `modelName`; null whenever the
+ * answer would be a guess. Callers must then skip the check — a missing
+ * descriptor turning into a wall of errors is worse than the gap it closes.
+ */
+export function getModelVisibility(packagesRoot, modelName) {
+    if (!packagesRoot || !modelName)
+        return null;
+    const key = `${packagesRoot.toLowerCase()}|${modelName.toLowerCase()}`;
+    const cached = visibilityCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    const built = buildModelVisibility(packagesRoot, modelName);
+    visibilityCache.set(key, built);
+    return built;
+}
+/** Uncached form — exported for tests, which need a fresh fixture each time. */
+export function buildModelVisibility(packagesRoot, modelName) {
+    if (!packagesRoot || !modelName)
+        return null;
+    const found = findDescriptor(packagesRoot, modelName);
+    if (!found)
+        return null;
+    let refs;
+    try {
+        refs = parseModuleReferences(readFileSync(found.file, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+    const visiblePackages = new Set([found.pkg.toLowerCase()]);
+    for (const ref of refs)
+        visiblePackages.add(ref.toLowerCase());
+    const rootPrefix = packagesRoot.replace(/\//g, '\\').replace(/\\+$/, '').toLowerCase() + '\\';
+    return {
+        model: modelName,
+        packagesRoot,
+        visiblePackages,
+        packageOf(filePath) {
+            if (!filePath)
+                return null;
+            const norm = filePath.replace(/\//g, '\\');
+            // Case-insensitive: index and config disagree on the root's casing
+            // (`K:\AOSService\…` vs `K:\AosService\…`) for the same directory.
+            if (!norm.toLowerCase().startsWith(rootPrefix))
+                return null;
+            const segment = norm.slice(rootPrefix.length).split('\\')[0];
+            return segment || null;
+        },
+    };
+}
+/** Test seam — drops the memoised visibility oracles. */
+export function clearModelVisibilityCache() {
+    visibilityCache.clear();
+}
+//# sourceMappingURL=modelDescriptor.js.map

package/dist/metadata/symbolIndex.js

@@ -6,6 +6,7 @@ import Database from '../database/sqlite.js';
 import { Worker } from 'node:worker_threads';
 import * as fs from 'fs';
 import * as path from 'path';
+import { renderMethodSignature } from './xppDeclaration.js';
 import { isStandardModel } from '../utils/modelClassifier.js';
 import { c, log } from '../utils/terminalUi.js';
 /**
@@ -1531,12 +1532,11 @@ export class XppSymbolIndex {
                 // Add method symbols with enhanced metadata
                 if (classData.methods && Array.isArray(classData.methods)) {
                     for (const method of classData.methods) {
-                        const params = method.parameters?.map((p) => `${p.type} ${p.name}`).join(', ') || '';
                         this.addSymbol({
                             name: method.name,
                             type: 'method',
                             parentName: classData.name,
-                            signature: `${method.returnType} ${method.name}(${params})`,
+                            signature: renderMethodSignature(method),
                             filePath: sourceFilePath,
                             model,
                             description: method.documentation,
@@ -1595,12 +1595,11 @@ export class XppSymbolIndex {
                 // Add method symbols (parallel to indexClasses)
                 if (tableData.methods && Array.isArray(tableData.methods)) {
                     for (const method of tableData.methods) {
-                        const params = method.parameters?.map((p) => `${p.type} ${p.name}`).join(', ') || '';
                         this.addSymbol({
                             name: method.name,
                             type: 'method',
                             parentName: tableData.name,
-                            signature: `${method.returnType} ${method.name}(${params})`,
+                            signature: renderMethodSignature(method),
                             filePath: sourceFilePath,
                             model,
                             description: method.documentation,
@@ -1848,12 +1847,11 @@ export class XppSymbolIndex {
                 // Add method symbols (views and data-entities can have display/computed methods)
                 if (viewData.methods && Array.isArray(viewData.methods)) {
                     for (const method of viewData.methods) {
-                        const params = method.parameters?.map((p) => `${p.type} ${p.name}`).join(', ') || '';
                         this.addSymbol({
                             name: method.name,
                             type: 'method',
                             parentName: viewName,
-                            signature: `${method.returnType} ${method.name}(${params})`,
+                            signature: renderMethodSignature(method),
                             filePath: sourceFilePath,
                             model,
                             description: method.documentation,

package/dist/metadata/types.d.ts

@@ -34,6 +34,12 @@ export interface XppMethodInfo {
     visibility: 'public' | 'private' | 'protected';
     returnType: string;
     parameters: XppParameterInfo[];
+    /**
+     * Declaration unparseable, so `parameters` is empty for lack of evidence
+     * rather than because the method takes none. Arity checks must skip, not
+     * assume zero.
+     */
+    parametersUnknown?: boolean;
     isStatic: boolean;
     source: string;
     documentation?: string;
@@ -48,6 +54,8 @@ export interface XppMethodInfo {
 export interface XppParameterInfo {
     name: string;
     type: string;
+    /** Default as declared; a dropped default makes an optional parameter look required. */
+    defaultValue?: string;
 }
 export interface XppTableInfo {
     name: string;

package/dist/metadata/xmlParser.d.ts

@@ -93,7 +93,11 @@ export declare class XppMetadataParser {
     private parseViewRelationFields;
     private extractLabelId;
     private ensureArray;
-    /** Declaration parameters narrowed to the shape XppMethodInfo carries. */
+    /**
+     * Declaration parameters narrowed to the shape XppMethodInfo carries.
+     * A null decl yields `[]`; the `parametersUnknown` flag set alongside is what
+     * tells that apart from a genuinely empty list, so don't read this alone.
+     */
     private toParameterInfo;
     /**
      * Parse Form XML file (AxForm)

package/dist/metadata/xmlParser.js

@@ -262,6 +262,7 @@ export class XppMetadataParser {
                 visibility: this.parseVisibility(method.Visibility),
                 returnType: decl?.returnType || method.ReturnType || 'void',
                 parameters: this.toParameterInfo(decl),
+                parametersUnknown: decl === null,
                 isStatic: decl?.modifiers.includes('static') ?? false,
                 source: source,
                 documentation: method.DeveloperDocumentation || undefined,
@@ -441,9 +442,15 @@ export class XppMetadataParser {
             return [];
         return Array.isArray(value) ? value : [value];
     }
-    /** Declaration parameters narrowed to the shape XppMethodInfo carries. */
+    /**
+     * Declaration parameters narrowed to the shape XppMethodInfo carries.
+     * A null decl yields `[]`; the `parametersUnknown` flag set alongside is what
+     * tells that apart from a genuinely empty list, so don't read this alone.
+     */
     toParameterInfo(decl) {
-        return decl?.parameters.map(p => ({ type: p.type, name: p.name })) ?? [];
+        return decl?.parameters.map(p => (p.defaultValue
+            ? { type: p.type, name: p.name, defaultValue: p.defaultValue }
+            : { type: p.type, name: p.name })) ?? [];
     }
     /**
      * Parse Form XML file (AxForm)
@@ -561,6 +568,7 @@ export class XppMetadataParser {
                 visibility: 'public', // Forms typically have public methods
                 returnType: decl?.returnType || 'void',
                 parameters: this.toParameterInfo(decl),
+                parametersUnknown: decl === null,
                 isStatic: decl?.modifiers.includes('static') ?? false,
                 source,
                 sourceSnippet: source.split('\n').slice(0, 10).join('\n'),

package/dist/metadata/xppDeclaration.d.ts

@@ -26,6 +26,28 @@ export interface XppDeclaration {
     returnType: string;
     parameters: XppDeclarationParameter[];
 }
+/** Rendered for a parameter list that could not be read; not legal X++, so it can't collide with a real one. */
+export declare const UNKNOWN_PARAMETER_LIST = "...";
+/** The subset of a method that `renderMethodSignature` needs. */
+export interface RenderableMethod {
+    name: string;
+    returnType?: string;
+    parameters?: ReadonlyArray<{
+        type: string;
+        name: string;
+        defaultValue?: string;
+    }> | null;
+    /** See XppMethodInfo.parametersUnknown. */
+    parametersUnknown?: boolean;
+}
+/**
+ * Render `ReturnType name(Type _a, Type _b = default)` for the symbol index.
+ *
+ * Defaults are kept and an unreadable list renders as `(...)`, never `()` —
+ * resolve_references reads this string back and gates writes on it, so `()` is
+ * a positive claim of zero parameters that consumers act on.
+ */
+export declare function renderMethodSignature(method: RenderableMethod): string;
 export interface XppClassHeader {
     kind: 'class' | 'interface';
     name: string;

package/dist/metadata/xppDeclaration.js

@@ -15,6 +15,23 @@
  * A parse that cannot be trusted returns null so callers fall through to their
  * own fallbacks, rather than emitting a confidently wrong signature.
  */
+/** Rendered for a parameter list that could not be read; not legal X++, so it can't collide with a real one. */
+export const UNKNOWN_PARAMETER_LIST = '...';
+/**
+ * Render `ReturnType name(Type _a, Type _b = default)` for the symbol index.
+ *
+ * Defaults are kept and an unreadable list renders as `(...)`, never `()` —
+ * resolve_references reads this string back and gates writes on it, so `()` is
+ * a positive claim of zero parameters that consumers act on.
+ */
+export function renderMethodSignature(method) {
+    const params = method.parametersUnknown
+        ? UNKNOWN_PARAMETER_LIST
+        : (method.parameters ?? [])
+            .map(p => `${p.type} ${p.name}${p.defaultValue ? ` = ${p.defaultValue}` : ''}`)
+            .join(', ');
+    return `${method.returnType ?? 'void'} ${method.name}(${params})`;
+}
 export const MODIFIER_KEYWORDS = [
     'public', 'private', 'protected', 'internal', 'static', 'final', 'abstract', 'display', 'edit',
 ];
@@ -126,6 +143,20 @@ function isTypeToken(t) {
 function isNameToken(t) {
     return /^[A-Za-z_]\w*$/.test(t);
 }
+/**
+ * Slice `raw` from `from`, trimmed to the extent that still carries content in
+ * the blanked twin — comments became whitespace there and so drop out, while
+ * string literals survive (their quotes are not blanked).
+ */
+function sliceByBlankedExtent(raw, blanked, from) {
+    let start = from;
+    while (start < blanked.length && /\s/.test(blanked[start]))
+        start++;
+    let end = blanked.length;
+    while (end > start && /\s/.test(blanked[end - 1]))
+        end--;
+    return raw.slice(start, end).replace(/\s+/g, ' ');
+}
 /**
  * Parse one "Type _name [= default]" parameter; null when it doesn't look like
  * a declared parameter (which is how a call's arguments are told apart from a
@@ -146,8 +177,11 @@ function parseParameter(raw, blanked) {
             break;
         }
     }
-    const left = (eq >= 0 ? raw.slice(0, eq) : raw).trim().replace(/\s+/g, ' ');
-    const defaultValue = eq >= 0 ? raw.slice(eq + 1).trim().replace(/\s+/g, ' ') : undefined;
+    // Type and name come off the blanked twin: the standard models interleave
+    // pragma comments inside wrapped parameter lists, and read raw those look
+    // like a leading type token, failing the parameter and discarding the lot.
+    const left = (eq >= 0 ? blanked.slice(0, eq) : blanked).trim().replace(/\s+/g, ' ');
+    const defaultValue = eq >= 0 ? sliceByBlankedExtent(raw, blanked, eq + 1) : undefined;
     const tokens = left.split(' ').filter(Boolean);
     if (tokens.length < 2)
         return null;

package/dist/scripts/build-database.js

@@ -785,6 +785,13 @@ import { Worker } from "node:worker_threads";
 import * as fs2 from "fs";
 import * as path from "path";
 
+// src/metadata/xppDeclaration.ts
+var UNKNOWN_PARAMETER_LIST = "...";
+function renderMethodSignature(method) {
+  const params = method.parametersUnknown ? UNKNOWN_PARAMETER_LIST : (method.parameters ?? []).map((p) => `${p.type} ${p.name}${p.defaultValue ? ` = ${p.defaultValue}` : ""}`).join(", ");
+  return `${method.returnType ?? "void"} ${method.name}(${params})`;
+}
+
 // src/utils/modelClassifier.ts
 var autoDetectedCustomModels = /* @__PURE__ */ new Set();
 function isAutoDetectedCustomModel(modelName) {
@@ -2342,12 +2349,11 @@ Point the installation at a drive with room (a full index needs several GB): re-
         });
         if (classData.methods && Array.isArray(classData.methods)) {
           for (const method of classData.methods) {
-            const params = method.parameters?.map((p) => `${p.type} ${p.name}`).join(", ") || "";
             this.addSymbol({
               name: method.name,
               type: "method",
               parentName: classData.name,
-              signature: `${method.returnType} ${method.name}(${params})`,
+              signature: renderMethodSignature(method),
               filePath: sourceFilePath,
               model,
               description: method.documentation,
@@ -2401,12 +2407,11 @@ Point the installation at a drive with room (a full index needs several GB): re-
         }
         if (tableData.methods && Array.isArray(tableData.methods)) {
           for (const method of tableData.methods) {
-            const params = method.parameters?.map((p) => `${p.type} ${p.name}`).join(", ") || "";
             this.addSymbol({
               name: method.name,
               type: "method",
               parentName: tableData.name,
-              signature: `${method.returnType} ${method.name}(${params})`,
+              signature: renderMethodSignature(method),
               filePath: sourceFilePath,
               model,
               description: method.documentation,
@@ -2659,12 +2664,11 @@ Point the installation at a drive with room (a full index needs several GB): re-
         }
         if (viewData.methods && Array.isArray(viewData.methods)) {
           for (const method of viewData.methods) {
-            const params = method.parameters?.map((p) => `${p.type} ${p.name}`).join(", ") || "";
             this.addSymbol({
               name: method.name,
               type: "method",
               parentName: viewName,
-              signature: `${method.returnType} ${method.name}(${params})`,
+              signature: renderMethodSignature(method),
               filePath: sourceFilePath,
               model,
               description: method.documentation,

package/dist/scripts/build-fts.js

@@ -784,6 +784,13 @@ import { Worker } from "node:worker_threads";
 import * as fs2 from "fs";
 import * as path from "path";
 
+// src/metadata/xppDeclaration.ts
+var UNKNOWN_PARAMETER_LIST = "...";
+function renderMethodSignature(method) {
+  const params = method.parametersUnknown ? UNKNOWN_PARAMETER_LIST : (method.parameters ?? []).map((p) => `${p.type} ${p.name}${p.defaultValue ? ` = ${p.defaultValue}` : ""}`).join(", ");
+  return `${method.returnType ?? "void"} ${method.name}(${params})`;
+}
+
 // src/utils/modelClassifier.ts
 var autoDetectedCustomModels = /* @__PURE__ */ new Set();
 function isAutoDetectedCustomModel(modelName) {
@@ -2281,12 +2288,11 @@ Point the installation at a drive with room (a full index needs several GB): re-
         });
         if (classData.methods && Array.isArray(classData.methods)) {
           for (const method of classData.methods) {
-            const params = method.parameters?.map((p) => `${p.type} ${p.name}`).join(", ") || "";
             this.addSymbol({
               name: method.name,
               type: "method",
               parentName: classData.name,
-              signature: `${method.returnType} ${method.name}(${params})`,
+              signature: renderMethodSignature(method),
               filePath: sourceFilePath,
               model,
               description: method.documentation,
@@ -2340,12 +2346,11 @@ Point the installation at a drive with room (a full index needs several GB): re-
         }
         if (tableData.methods && Array.isArray(tableData.methods)) {
           for (const method of tableData.methods) {
-            const params = method.parameters?.map((p) => `${p.type} ${p.name}`).join(", ") || "";
             this.addSymbol({
               name: method.name,
               type: "method",
               parentName: tableData.name,
-              signature: `${method.returnType} ${method.name}(${params})`,
+              signature: renderMethodSignature(method),
               filePath: sourceFilePath,
               model,
               description: method.documentation,
@@ -2598,12 +2603,11 @@ Point the installation at a drive with room (a full index needs several GB): re-
         }
         if (viewData.methods && Array.isArray(viewData.methods)) {
           for (const method of viewData.methods) {
-            const params = method.parameters?.map((p) => `${p.type} ${p.name}`).join(", ") || "";
             this.addSymbol({
               name: method.name,
               type: "method",
               parentName: viewName,
-              signature: `${method.returnType} ${method.name}(${params})`,
+              signature: renderMethodSignature(method),
               filePath: sourceFilePath,
               model,
               description: method.documentation,