d365fo-mcp 1.2.0 → 1.3.0

package/dist/bridge/bridgeAdapter.js

@@ -1009,6 +1009,9 @@ const BRIDGE_MODIFY_OPS = new Set([
     'add-field', 'modify-field', 'rename-field', 'replace-all-fields', 'remove-field',
     'add-index', 'remove-index',
     'add-relation', 'remove-relation',
+    // No C# op backs these — they are served by a direct-XML writer, but they still
+    // pass through the same modify gate.
+    'add-delete-action', 'remove-delete-action',
     'add-field-group', 'remove-field-group', 'add-field-to-field-group',
     'modify-property',
     'add-enum-value', 'modify-enum-value', 'remove-enum-value',

package/dist/cli/commands/indexCmd.js

@@ -4,7 +4,7 @@
  * instances/rebuild-instance.ps1 minus the git-pull step (that lives in
  * `d365fo-mcp update`).
  */
-import { installMode, isWindows, paths } from '../context.js';
+import { dataRoot, installMode, isWindows, paths } from '../context.js';
 import { runNode } from '../exec.js';
 import { listInstances } from '../instances.js';
 import { instanceTarget, pickTarget, rootTarget, targetEnv } from '../target.js';
@@ -25,18 +25,24 @@ function scriptArgs(tsSource, bundle) {
 /** Run extract + build-database for one target. Returns true on success. */
 export async function rebuildIndex(target) {
     const env = targetEnv(target);
+    // Run from the target's own directory, not the package: the index scripts
+    // fall back to relative literals ('./data/xpp-metadata.db') whenever a
+    // setting is absent AND no config file exists to anchor it, and the default
+    // cwd of runNode is repoRoot — which for an npm install is the package npm
+    // replaces on every update, on whatever drive npm happens to live on.
+    const cwd = target.instance?.dir ?? dataRoot();
     if (isWindows) {
         const expanded = normalizeXppConfigName(target.store);
         if (expanded)
             p.log.info(`Expanded XPP config name: ${expanded.from} → ${expanded.to}`);
     }
     p.log.step(`[1/2] Extracting metadata (${target.label})…`);
-    if (await runNode(scriptArgs(paths.extractScript, paths.extractScriptDist), { env }) !== 0) {
+    if (await runNode(scriptArgs(paths.extractScript, paths.extractScriptDist), { cwd, env }) !== 0) {
         p.log.error(`Metadata extraction failed for ${target.label}`);
         return false;
     }
     p.log.step(`[2/2] Building database (${target.label})…`);
-    if (await runNode(['--max-old-space-size=6144', ...scriptArgs(paths.buildDbScript, paths.buildDbScriptDist)], { env }) !== 0) {
+    if (await runNode(['--max-old-space-size=6144', ...scriptArgs(paths.buildDbScript, paths.buildDbScriptDist)], { cwd, env }) !== 0) {
         p.log.error(`Database build failed for ${target.label}`);
         return false;
     }

package/dist/config/configFile.d.ts

@@ -41,6 +41,23 @@ export declare function configBaseDir(configPath: string): string;
  * can use portable values like ./data/xpp-metadata.db.
  */
 export declare function toEnvRecord(files: Pick<ResolvedConfigFiles, 'baseDir' | 'config' | 'secrets'>): Record<string, string>;
+/**
+ * The path settings the wizard never writes, resolved against `baseDir`.
+ *
+ * DB_PATH, LABELS_DB_PATH and METADATA_PATH are advanced settings with
+ * relative defaults, so a normal setup leaves them out of the config file
+ * entirely and every consumer falls back to its own `'./data/…'` literal —
+ * which resolves from process.cwd(). For a git checkout that is the repo, and
+ * the answer happens to be right. For an npm install it is the *package*
+ * directory: `d365fo-mcp index` spawns the build scripts with cwd = repoRoot,
+ * so a 2 GB index landed next to the installed package, on whatever drive npm
+ * lives on, instead of in the installation directory the user chose in setup
+ * (issue: build ran out of space on C: and SQLite aborted the transaction).
+ *
+ * Emitting the defaults here pins them to the installation directory instead.
+ * A checkout is its own data directory, so its paths do not move.
+ */
+export declare function defaultPathEnv(baseDir: string): Record<string, string>;
 /** Write the config file, creating its directory. Keys are emitted in registry order. */
 export declare function writeConfigFile(configPath: string, config: ConfigObject): void;
 /** Write secrets.json with owner-only permissions where the platform supports them. */

package/dist/config/configFile.js

@@ -111,6 +111,31 @@ export function toEnvRecord(files) {
     }
     return out;
 }
+/**
+ * The path settings the wizard never writes, resolved against `baseDir`.
+ *
+ * DB_PATH, LABELS_DB_PATH and METADATA_PATH are advanced settings with
+ * relative defaults, so a normal setup leaves them out of the config file
+ * entirely and every consumer falls back to its own `'./data/…'` literal —
+ * which resolves from process.cwd(). For a git checkout that is the repo, and
+ * the answer happens to be right. For an npm install it is the *package*
+ * directory: `d365fo-mcp index` spawns the build scripts with cwd = repoRoot,
+ * so a 2 GB index landed next to the installed package, on whatever drive npm
+ * lives on, instead of in the installation directory the user chose in setup
+ * (issue: build ran out of space on C: and SQLite aborted the transaction).
+ *
+ * Emitting the defaults here pins them to the installation directory instead.
+ * A checkout is its own data directory, so its paths do not move.
+ */
+export function defaultPathEnv(baseDir) {
+    const out = {};
+    for (const setting of SETTINGS) {
+        if (setting.type !== 'path' || typeof setting.default !== 'string' || setting.default === '')
+            continue;
+        out[setting.env] = isAbsolute(setting.default) ? setting.default : resolve(baseDir, setting.default);
+    }
+    return out;
+}
 /** Write the config file, creating its directory. Keys are emitted in registry order. */
 export function writeConfigFile(configPath, config) {
     fs.mkdirSync(dirname(configPath), { recursive: true });

package/dist/metadata/symbolIndex.d.ts

@@ -212,6 +212,19 @@ export declare class XppSymbolIndex {
      *                   database (a custom-model build: ~10K of ~1.2M symbols, where the full
      *                   rebuild cost 327s against 5s of actual indexing work).
      */
+    /**
+     * Turn a write failure inside a model transaction into an error that names
+     * the database being written and, when the drive is the likely cause, how
+     * much room is left on it.
+     *
+     * A full disk makes SQLite roll the transaction back itself, so better-sqlite3's
+     * wrapper then fails to COMMIT and the only thing the user sees is
+     * "cannot commit - no transaction is active" with a stack inside the library —
+     * no path, no mention of space. That message sent at least one user hunting
+     * for a corrupt index when the index was simply being written to the wrong
+     * (and nearly full) drive.
+     */
+    private describeWriteFailure;
     indexMetadataDirectory(metadataPath: string, modelNames?: string | string[], opts?: {
         ftsStrategy?: 'rebuild' | 'incremental';
     }): Promise<void>;

package/dist/metadata/symbolIndex.js

@@ -1172,6 +1172,41 @@ export class XppSymbolIndex {
      *                   database (a custom-model build: ~10K of ~1.2M symbols, where the full
      *                   rebuild cost 327s against 5s of actual indexing work).
      */
+    /**
+     * Turn a write failure inside a model transaction into an error that names
+     * the database being written and, when the drive is the likely cause, how
+     * much room is left on it.
+     *
+     * A full disk makes SQLite roll the transaction back itself, so better-sqlite3's
+     * wrapper then fails to COMMIT and the only thing the user sees is
+     * "cannot commit - no transaction is active" with a stack inside the library —
+     * no path, no mention of space. That message sent at least one user hunting
+     * for a corrupt index when the index was simply being written to the wrong
+     * (and nearly full) drive.
+     */
+    describeWriteFailure(err, model) {
+        const original = err instanceof Error ? err : new Error(String(err));
+        const message = original.message;
+        const diskRelated = /disk is full|SQLITE_FULL|disk I\/O error|no transaction is active/i.test(message);
+        if (!diskRelated)
+            return original;
+        let space = '';
+        try {
+            const stat = fs.statfsSync(path.dirname(path.resolve(this.dbPath)));
+            const freeGb = (Number(stat.bavail) * Number(stat.bsize)) / 1024 ** 3;
+            space = ` (${freeGb.toFixed(1)} GB free there)`;
+        }
+        catch {
+            // statfs is best-effort — the path advice below is the useful part.
+        }
+        const wrapped = new Error(`Writing model '${model}' to ${this.dbPath} failed: ${message}\n` +
+            `The index is written to that path${space}. A full disk makes SQLite roll the write back on its own, ` +
+            `which is what surfaces as "cannot commit - no transaction is active".\n` +
+            `Point the installation at a drive with room (a full index needs several GB): ` +
+            `re-run 'd365fo-mcp setup' and choose another directory, or set index.dbPath / index.metadataPath in d365fo-mcp.json.`);
+        wrapped.cause = original;
+        return wrapped;
+    }
     async indexMetadataDirectory(metadataPath, modelNames, opts) {
         const skipFts = process.env.SKIP_FTS === 'true';
         const resumable = process.env.RESUME === 'true';
@@ -1357,7 +1392,12 @@ export class XppSymbolIndex {
                 // Mark model as done atomically with its data (same transaction)
                 markProgress?.run(model, Date.now());
             });
-            tx();
+            try {
+                tx();
+            }
+            catch (err) {
+                throw this.describeWriteFailure(err, model);
+            }
             const modelDuration = ((Date.now() - modelStartTime) / 1000).toFixed(1);
             const elapsed = ((Date.now() - startTime) / 1000).toFixed(0);
             if (isCI()) {

package/dist/scripts/build-database.js

@@ -595,6 +595,14 @@ function toEnvRecord(files) {
   }
   return out;
 }
+function defaultPathEnv(baseDir) {
+  const out = {};
+  for (const setting of SETTINGS) {
+    if (setting.type !== "path" || typeof setting.default !== "string" || setting.default === "") continue;
+    out[setting.env] = isAbsolute(setting.default) ? setting.default : resolve(baseDir, setting.default);
+  }
+  return out;
+}
 
 // src/utils/loadEnv.ts
 var PATH_VARS = ["DB_PATH", "LABELS_DB_PATH", "METADATA_PATH"];
@@ -629,6 +637,9 @@ function loadEnv(callerImportMetaUrl) {
   for (const [key, value] of Object.entries(toEnvRecord(files))) {
     if (!fromRealEnv.has(key) && !pinnedByEnvFile.has(key)) process.env[key] = value;
   }
+  for (const [key, value] of Object.entries(defaultPathEnv(files.baseDir))) {
+    if (!process.env[key]) process.env[key] = value;
+  }
   if (process.env.D365FO_DEV_ENVIRONMENT_TYPE) {
     process.env.DEV_ENVIRONMENT_TYPE = process.env.D365FO_DEV_ENVIRONMENT_TYPE;
   }
@@ -1764,13 +1775,13 @@ var XppSymbolIndex = class _XppSymbolIndex {
     if (this.dbPath === ":memory:") {
       return Promise.reject(new Error("in-memory DB is not visible to worker threads"));
     }
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const worker = new Worker(new URL("./symbolCountsWorker.js", import.meta.url), {
         workerData: { dbPath: this.dbPath }
       });
       worker.once("message", (msg) => {
         if (msg.ok) {
-          resolve3({ total: msg.total, byType: msg.byType });
+          resolve4({ total: msg.total, byType: msg.byType });
         } else {
           reject(new Error(msg.error));
         }
@@ -1928,6 +1939,38 @@ var XppSymbolIndex = class _XppSymbolIndex {
    *                   database (a custom-model build: ~10K of ~1.2M symbols, where the full
    *                   rebuild cost 327s against 5s of actual indexing work).
    */
+  /**
+   * Turn a write failure inside a model transaction into an error that names
+   * the database being written and, when the drive is the likely cause, how
+   * much room is left on it.
+   *
+   * A full disk makes SQLite roll the transaction back itself, so better-sqlite3's
+   * wrapper then fails to COMMIT and the only thing the user sees is
+   * "cannot commit - no transaction is active" with a stack inside the library —
+   * no path, no mention of space. That message sent at least one user hunting
+   * for a corrupt index when the index was simply being written to the wrong
+   * (and nearly full) drive.
+   */
+  describeWriteFailure(err, model) {
+    const original = err instanceof Error ? err : new Error(String(err));
+    const message = original.message;
+    const diskRelated = /disk is full|SQLITE_FULL|disk I\/O error|no transaction is active/i.test(message);
+    if (!diskRelated) return original;
+    let space = "";
+    try {
+      const stat2 = fs2.statfsSync(path.dirname(path.resolve(this.dbPath)));
+      const freeGb = Number(stat2.bavail) * Number(stat2.bsize) / 1024 ** 3;
+      space = ` (${freeGb.toFixed(1)} GB free there)`;
+    } catch {
+    }
+    const wrapped = new Error(
+      `Writing model '${model}' to ${this.dbPath} failed: ${message}
+The index is written to that path${space}. A full disk makes SQLite roll the write back on its own, which is what surfaces as "cannot commit - no transaction is active".
+Point the installation at a drive with room (a full index needs several GB): re-run 'd365fo-mcp setup' and choose another directory, or set index.dbPath / index.metadataPath in d365fo-mcp.json.`
+    );
+    wrapped.cause = original;
+    return wrapped;
+  }
   async indexMetadataDirectory(metadataPath, modelNames, opts) {
     const skipFts = process.env.SKIP_FTS === "true";
     const resumable = process.env.RESUME === "true";
@@ -2045,7 +2088,11 @@ var XppSymbolIndex = class _XppSymbolIndex {
         this.flushPropertyStats();
         markProgress?.run(model, Date.now());
       });
-      tx();
+      try {
+        tx();
+      } catch (err) {
+        throw this.describeWriteFailure(err, model);
+      }
       const modelDuration = ((Date.now() - modelStartTime) / 1e3).toFixed(1);
       const elapsed = ((Date.now() - startTime) / 1e3).toFixed(0);
       if (isCI()) {

package/dist/scripts/build-fts.js

@@ -595,6 +595,14 @@ function toEnvRecord(files) {
   }
   return out;
 }
+function defaultPathEnv(baseDir) {
+  const out = {};
+  for (const setting of SETTINGS) {
+    if (setting.type !== "path" || typeof setting.default !== "string" || setting.default === "") continue;
+    out[setting.env] = isAbsolute(setting.default) ? setting.default : resolve(baseDir, setting.default);
+  }
+  return out;
+}
 
 // src/utils/loadEnv.ts
 var PATH_VARS = ["DB_PATH", "LABELS_DB_PATH", "METADATA_PATH"];
@@ -629,6 +637,9 @@ function loadEnv(callerImportMetaUrl) {
   for (const [key, value] of Object.entries(toEnvRecord(files))) {
     if (!fromRealEnv.has(key) && !pinnedByEnvFile.has(key)) process.env[key] = value;
   }
+  for (const [key, value] of Object.entries(defaultPathEnv(files.baseDir))) {
+    if (!process.env[key]) process.env[key] = value;
+  }
   if (process.env.D365FO_DEV_ENVIRONMENT_TYPE) {
     process.env.DEV_ENVIRONMENT_TYPE = process.env.D365FO_DEV_ENVIRONMENT_TYPE;
   }
@@ -1703,13 +1714,13 @@ var XppSymbolIndex = class _XppSymbolIndex {
     if (this.dbPath === ":memory:") {
       return Promise.reject(new Error("in-memory DB is not visible to worker threads"));
     }
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const worker = new Worker(new URL("./symbolCountsWorker.js", import.meta.url), {
         workerData: { dbPath: this.dbPath }
       });
       worker.once("message", (msg) => {
         if (msg.ok) {
-          resolve3({ total: msg.total, byType: msg.byType });
+          resolve4({ total: msg.total, byType: msg.byType });
         } else {
           reject(new Error(msg.error));
         }
@@ -1867,6 +1878,38 @@ var XppSymbolIndex = class _XppSymbolIndex {
    *                   database (a custom-model build: ~10K of ~1.2M symbols, where the full
    *                   rebuild cost 327s against 5s of actual indexing work).
    */
+  /**
+   * Turn a write failure inside a model transaction into an error that names
+   * the database being written and, when the drive is the likely cause, how
+   * much room is left on it.
+   *
+   * A full disk makes SQLite roll the transaction back itself, so better-sqlite3's
+   * wrapper then fails to COMMIT and the only thing the user sees is
+   * "cannot commit - no transaction is active" with a stack inside the library —
+   * no path, no mention of space. That message sent at least one user hunting
+   * for a corrupt index when the index was simply being written to the wrong
+   * (and nearly full) drive.
+   */
+  describeWriteFailure(err, model) {
+    const original = err instanceof Error ? err : new Error(String(err));
+    const message = original.message;
+    const diskRelated = /disk is full|SQLITE_FULL|disk I\/O error|no transaction is active/i.test(message);
+    if (!diskRelated) return original;
+    let space = "";
+    try {
+      const stat = fs2.statfsSync(path.dirname(path.resolve(this.dbPath)));
+      const freeGb = Number(stat.bavail) * Number(stat.bsize) / 1024 ** 3;
+      space = ` (${freeGb.toFixed(1)} GB free there)`;
+    } catch {
+    }
+    const wrapped = new Error(
+      `Writing model '${model}' to ${this.dbPath} failed: ${message}
+The index is written to that path${space}. A full disk makes SQLite roll the write back on its own, which is what surfaces as "cannot commit - no transaction is active".
+Point the installation at a drive with room (a full index needs several GB): re-run 'd365fo-mcp setup' and choose another directory, or set index.dbPath / index.metadataPath in d365fo-mcp.json.`
+    );
+    wrapped.cause = original;
+    return wrapped;
+  }
   async indexMetadataDirectory(metadataPath, modelNames, opts) {
     const skipFts = process.env.SKIP_FTS === "true";
     const resumable = process.env.RESUME === "true";
@@ -1984,7 +2027,11 @@ var XppSymbolIndex = class _XppSymbolIndex {
         this.flushPropertyStats();
         markProgress?.run(model, Date.now());
       });
-      tx();
+      try {
+        tx();
+      } catch (err) {
+        throw this.describeWriteFailure(err, model);
+      }
       const modelDuration = ((Date.now() - modelStartTime) / 1e3).toFixed(1);
       const elapsed = ((Date.now() - startTime) / 1e3).toFixed(0);
       if (isCI()) {

package/dist/scripts/extract-metadata.js

@@ -595,6 +595,14 @@ function toEnvRecord(files) {
   }
   return out;
 }
+function defaultPathEnv(baseDir) {
+  const out = {};
+  for (const setting of SETTINGS) {
+    if (setting.type !== "path" || typeof setting.default !== "string" || setting.default === "") continue;
+    out[setting.env] = isAbsolute(setting.default) ? setting.default : resolve(baseDir, setting.default);
+  }
+  return out;
+}
 
 // src/utils/loadEnv.ts
 var PATH_VARS = ["DB_PATH", "LABELS_DB_PATH", "METADATA_PATH"];
@@ -629,6 +637,9 @@ function loadEnv(callerImportMetaUrl) {
   for (const [key, value] of Object.entries(toEnvRecord(files))) {
     if (!fromRealEnv.has(key) && !pinnedByEnvFile.has(key)) process.env[key] = value;
   }
+  for (const [key, value] of Object.entries(defaultPathEnv(files.baseDir))) {
+    if (!process.env[key]) process.env[key] = value;
+  }
   if (process.env.D365FO_DEV_ENVIRONMENT_TYPE) {
     process.env.DEV_ENVIRONMENT_TYPE = process.env.D365FO_DEV_ENVIRONMENT_TYPE;
   }

package/dist/server/toolSchemas/d365foFile.js

@@ -116,6 +116,7 @@ Model from .mcp.json; prefix auto-applied from EXTENSION_PREFIX. Classes: member
                     'add-display-method', 'add-table-method',
                     'add-index', 'remove-index',
                     'add-relation', 'remove-relation',
+                    'add-delete-action', 'remove-delete-action',
                     'add-field-group', 'remove-field-group', 'add-field-to-field-group',
                     'add-field-modification',
                     'add-data-source', 'add-control',
@@ -131,6 +132,7 @@ Model from .mcp.json; prefix auto-applied from EXTENSION_PREFIX. Classes: member
                     'add-display-method: display method with [SysClientCacheDataMethodAttribute].\n' +
                     'add-table-method: canonical find/exist/findByRecId/validateWrite/validateDelete/initValue boilerplate.\n' +
                     'add-field-modification: override base-table field label/mandatory in a table-extension.\n' +
+                    'add-delete-action: table DeleteActions entry — deleteActionName + optional deleteActionTable/deleteActionType (None|Restricted|Cascade|CascadeRestricted).\n' +
                     'modify-property: any object-level property (TableGroup, TitleField1, TableType, Extends…) — see propertyPath.'
             },
             params: {

package/dist/server/toolSchemas/generateObject.d.ts

@@ -81,6 +81,10 @@ export declare const generateObjectTool: {
                 type: string;
                 description: string;
             };
+            preview: {
+                type: string;
+                description: string;
+            };
             dataSource: {
                 type: string;
                 description: string;

package/dist/server/toolSchemas/generateObject.js

@@ -74,6 +74,7 @@ export const generateObjectTool = {
                 description: '[scaffold:table] Storage type: Regular (default, omit), TempDB, InMemory. ⛔ NEVER pass as tableGroup.',
             },
             generateCommonFields: { type: 'boolean', description: '[scaffold:table] Auto-generate common fields based on table group patterns.' },
+            preview: { type: 'boolean', description: '[scaffold:table] Return the XML without writing to disk.' },
             dataSource: { type: 'string', description: '[scaffold:form] Optional: Table name for primary datasource.' },
             formPattern: {
                 type: 'string',
@@ -92,7 +93,7 @@ export const generateObjectTool = {
             generateControls: { type: 'boolean', description: '[scaffold:form] Auto-generate grid controls for datasource.' },
             fields: {
                 type: 'array',
-                description: '[scaffold:report | fields] Structured field specs. Takes priority over fieldsHint. For mode="fields": name + optional edt/enumType/type/label/mandatory (EDT auto-resolved when omitted).',
+                description: '[scaffold:table|report | fields] Structured field specs; takes priority over fieldsHint. PREFER for enum-backed fields or an explicit EDT — a bare name cannot express either. name + optional edt/enumType/type/label/mandatory (EDT auto-resolved when omitted).',
                 items: {
                     type: 'object',
                     properties: {

package/dist/server/toolSchemas/index.d.ts

@@ -208,6 +208,10 @@ export declare const toolSchemas: ({
                 type: string;
                 description: string;
             };
+            preview: {
+                type: string;
+                description: string;
+            };
             dataSource: {
                 type: string;
                 description: string;

package/dist/tools/d365foFileOpSpecs.js

@@ -42,6 +42,19 @@ export const D365FO_FILE_PARAM_SPECS = {
         type: 'string',
         description: 'Replacement for the first occurrence of oldCode; pass "" to delete the snippet.',
     },
+    // table delete actions
+    deleteActionName: {
+        type: 'string',
+        description: 'Delete action name — conventionally the related table name.',
+    },
+    deleteActionTable: {
+        type: 'string',
+        description: 'Related table the delete action applies to (defaults to deleteActionName).',
+    },
+    deleteActionType: {
+        type: 'string (None | Restricted | Cascade | CascadeRestricted)',
+        description: 'Delete action to take on the related table. Defaults to Restricted.',
+    },
     // table fields
     fieldName: { type: 'string', description: 'Field name.' },
     fieldNewName: {
@@ -269,6 +282,12 @@ export const D365FO_FILE_OP_SPECS = {
         optional: ['relationConstraints', 'relationCardinality', 'relatedTableCardinality', 'relationshipType'],
     },
     'remove-relation': { required: ['relationName'], optional: [] },
+    'add-delete-action': {
+        required: ['deleteActionName'],
+        optional: ['deleteActionTable', 'deleteActionType'],
+        note: 'objectType="table" only. deleteActionTable defaults to deleteActionName; deleteActionType defaults to Restricted.',
+    },
+    'remove-delete-action': { required: ['deleteActionName'], optional: [] },
     'add-field-group': {
         required: ['fieldGroupName'],
         optional: ['fieldGroupFields', 'fieldGroupLabel'],

package/dist/tools/generateObject.d.ts

@@ -16,19 +16,7 @@
 import type { CallToolRequest } from '@modelcontextprotocol/sdk/types.js';
 import type { XppServerContext } from '../types/context.js';
 export declare function generateObjectTool(request: CallToolRequest, context: XppServerContext): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError: boolean;
-} | {
-    isError?: undefined;
     content: any;
-} | {
-    content: {
-        type: 'text';
-        text: string;
-    }[];
     isError?: boolean | undefined;
 }>;
 //# sourceMappingURL=generateObject.d.ts.map

package/dist/tools/generateSmart.d.ts

@@ -19,14 +19,8 @@ export type GenerateSmartType = (typeof GENERATE_SMART_TYPES)[number];
 type SmartHandler = (args: any, context: XppServerContext) => Promise<any>;
 export declare const GENERATE_SMART_DISPATCH: Record<GenerateSmartType, SmartHandler>;
 export declare function generateSmartTool(request: CallToolRequest, context: XppServerContext): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError: boolean;
-} | {
-    isError?: undefined;
     content: any;
+    isError?: boolean | undefined;
 }>;
 export {};
 //# sourceMappingURL=generateSmart.d.ts.map

package/dist/tools/generateSmart.js

@@ -45,7 +45,11 @@ export async function generateSmartTool(request, context) {
         };
     }
     const result = await handler(rest, context);
-    return { content: result?.content ?? [{ type: 'text', text: 'No results returned' }] };
+    // Preserve isError — dropping it reported a rejected generation as a success.
+    return {
+        content: result?.content ?? [{ type: 'text', text: 'No results returned' }],
+        ...(result?.isError ? { isError: true } : {}),
+    };
 }
 // Tool registration (name, description, inputSchema) lives inline in
 // src/server/mcpServer.ts — the single source of truth for tool instructions.

package/dist/tools/generateSmartTable.d.ts

@@ -4,6 +4,7 @@
  */
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
 import { XppSymbolIndex } from '../metadata/symbolIndex.js';
+import { TableFieldSpec } from '../utils/smartXmlBuilder.js';
 import type { BridgeClient } from '../bridge/bridgeClient.js';
 interface GenerateSmartTableArgs {
     name: string;
@@ -20,8 +21,15 @@ interface GenerateSmartTableArgs {
     tableType?: string;
     copyFrom?: string;
     fieldsHint?: string;
+    /**
+     * Structured field specs. Takes priority over `fieldsHint`, which can only carry
+     * names and therefore cannot express enum-backed fields or an explicit EDT.
+     */
+    fields?: TableFieldSpec[];
     primaryKeyFields?: string[];
     generateCommonFields?: boolean;
+    /** Return the XML without touching disk. The default Windows path writes the file (eval #21). */
+    preview?: boolean;
     modelName?: string;
     projectPath?: string;
     solutionPath?: string;

package/dist/tools/generateSmartTable.js

@@ -118,7 +118,7 @@ export const generateSmartTableTool = {
     },
 };
 export async function handleGenerateSmartTable(args, symbolIndex, bridge) {
-    const { name, label, tableGroup = 'Main', tableType, copyFrom, fieldsHint, primaryKeyFields, generateCommonFields, modelName, projectPath, solutionPath, packagePath: argPackagePath, methods: requestedMethods, } = args;
+    const { name, label, tableGroup = 'Main', tableType, copyFrom, fieldsHint, fields: fieldSpecs, primaryKeyFields, generateCommonFields, preview, modelName, projectPath, solutionPath, packagePath: argPackagePath, methods: requestedMethods, } = args;
     // Guard: 'TempDB' and 'InMemory' are NOT valid TableGroup values.
     if (tableGroup === 'TempDB' || tableGroup === 'InMemory') {
         return {
@@ -200,9 +200,10 @@ export async function handleGenerateSmartTable(args, symbolIndex, bridge) {
             throw new Error(`Failed to copy structure from ${copyFrom}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    const explicitFields = Array.isArray(fieldSpecs) ? fieldSpecs.filter(f => f?.name) : [];
     // Strategy 2: Generate common fields based on table group patterns.
-    // Skipped when explicit fieldsHint is given (the caller stated the fields).
-    if (generateCommonFields && !copyFrom && !fieldsHint) {
+    // Skipped when the caller stated the fields (fields[] or fieldsHint).
+    if (generateCommonFields && !copyFrom && !fieldsHint && explicitFields.length === 0) {
         console.log(`[generateSmartTable] Analyzing patterns for table group: ${tableGroup}`);
         try {
             const db = symbolIndex.getReadDb();
@@ -258,15 +259,16 @@ export async function handleGenerateSmartTable(args, symbolIndex, bridge) {
             // Continue without pattern-based fields
         }
     }
-    // Strategy 3: Parse field hints and suggest EDTs
-    if (fieldsHint && !copyFrom) {
-        console.log(`[generateSmartTable] Parsing field hints: ${fieldsHint}`);
-        const hintFields = fieldsHint.split(',').map(s => s.trim()).filter(s => s.length > 0);
-        // Guard: reject reserved system field names before any generation attempt.
-        // Adding a field named e.g. "CreatedDateTime" produces a compiler error:
-        // "Invalid field name; 'CreatedDateTime' is reserved for system fields."
-        // The platform auto-provides these fields; users should NOT declare them.
-        const reservedHits = hintFields.filter(f => RESERVED_SYSTEM_FIELD_NAMES.has(f.toLowerCase()));
+    // Guard: reject reserved system field names before any generation attempt.
+    // Adding a field named e.g. "CreatedDateTime" produces a compiler error:
+    // "Invalid field name; 'CreatedDateTime' is reserved for system fields."
+    // The platform auto-provides these fields; users should NOT declare them.
+    {
+        const declaredNames = explicitFields.length > 0
+            ? explicitFields.map(f => f.name)
+            : (fieldsHint && !copyFrom ? fieldsHint.split(',').map(s => s.trim()).filter(s => s.length > 0) : []);
+        const sourceParam = explicitFields.length > 0 ? 'fields' : 'fieldsHint';
+        const reservedHits = declaredNames.filter(f => RESERVED_SYSTEM_FIELD_NAMES.has(f.toLowerCase()));
         if (reservedHits.length > 0) {
             return {
                 content: [{
@@ -295,12 +297,31 @@ export async function handleGenerateSmartTable(args, symbolIndex, bridge) {
                                 return `  • "${f}" → ${suggestions[f.toLowerCase()] ?? '"CustomFieldName"'}`;
                             }).join('\n')}`,
                             ``,
-                            `🔄 **Call generate again** with the corrected \`fieldsHint\`.`,
+                            `🔄 **Call generate again** with the corrected \`${sourceParam}\`.`,
                         ].join('\n'),
                     }],
                 isError: true,
             };
         }
+    }
+    // Strategy 3a: structured field specs. Preferred over fieldsHint — an enum-backed
+    // field or an explicit EDT cannot be expressed by a bare name (eval #21).
+    if (explicitFields.length > 0 && !copyFrom) {
+        const specDb = symbolIndex.getReadDb();
+        for (const spec of explicitFields) {
+            // enumType and an explicit type are authoritative; only resolve an EDT when
+            // neither was given and the caller did not name one.
+            const edt = spec.enumType || spec.type
+                ? spec.edt
+                : (spec.edt ?? resolveBestEdt(spec.name, specDb));
+            fields.push({ ...spec, edt });
+        }
+        console.log(`[generateSmartTable] Added ${explicitFields.length} fields from fields[]`);
+    }
+    // Strategy 3b: Parse field hints and suggest EDTs
+    if (fieldsHint && !copyFrom && explicitFields.length === 0) {
+        console.log(`[generateSmartTable] Parsing field hints: ${fieldsHint}`);
+        const hintFields = fieldsHint.split(',').map(s => s.trim()).filter(s => s.length > 0);
         const hintDb = symbolIndex.getReadDb();
         for (const hint of hintFields) {
             // On duplicate hint names, suffix the second occurrence instead of dropping it.
@@ -455,7 +476,9 @@ export async function handleGenerateSmartTable(args, symbolIndex, bridge) {
     const resolvedPackagePath = argPackagePath || customPackagesRoot || configManager.getPackagePath();
     // getPackagePath() already probes C:\ and K:\ well-known locations before returning null,
     // so reaching here with null means neither location exists on this machine.
-    if (!resolvedPackagePath && process.platform === 'win32') {
+    // preview never writes, so it must not require a write location — demanding one
+    // made "just show me the XML" fail on any machine without a D365FO install.
+    if (!resolvedPackagePath && process.platform === 'win32' && !preview) {
         throw new Error('\u274c Cannot determine PackagesLocalDirectory path.\n\n' +
             'Neither C:\\AosService\\PackagesLocalDirectory nor K:\\AosService\\PackagesLocalDirectory were found.\n\n' +
             'If your D365FO installation is on a different drive, add one of the following to your .mcp.json:\n' +
@@ -635,9 +658,9 @@ export async function handleGenerateSmartTable(args, symbolIndex, bridge) {
             isError: true,
         };
     }
-    // On non-Windows (Azure/Linux): generate XML via SmartXmlBuilder and return as text
-    // The bridge is not available on non-Windows — file writing is handled by the local companion.
-    if (isNonWindows) {
+    // Text-only path: non-Windows (bridge unavailable, the local companion writes the file)
+    // or an explicit preview=true, which is the only way to scaffold without a disk write.
+    if (isNonWindows || preview) {
         const xml = builder.buildTableXml({
             name: finalName,
             label: label || finalName,
@@ -679,7 +702,9 @@ export async function handleGenerateSmartTable(args, symbolIndex, bridge) {
                         edtWarningBlock,
                         noModelNote,
                         ``,
-                        `ℹ️  MCP server is running on Azure/Linux — file writing is handled by the local Windows companion. This is the expected hybrid workflow.`,
+                        preview && !isNonWindows
+                            ? `ℹ️  preview=true — nothing was written to disk.`
+                            : `ℹ️  MCP server is running on Azure/Linux — file writing is handled by the local Windows companion. This is the expected hybrid workflow.`,
                         nextStep,
                         ``,
                         `\`\`\`xml`,

package/dist/tools/modifyD365File.d.ts

@@ -75,6 +75,8 @@ export declare function extractMethodNameFromSource(source: string | undefined):
  * Anything unrecognised returns undefined so the op's own default applies.
  */
 export declare function coerceNoYesFlag(value: unknown): boolean | undefined;
+/** DeleteAction values accepted by the AxTable serialiser. */
+export declare const DELETE_ACTION_TYPES: readonly ['None', 'Restricted', 'Cascade', 'CascadeRestricted'];
 /**
  * Writes the relation properties the bridge drops into an <AxTableRelation>.
  *

package/dist/tools/modifyD365File.js

@@ -19,6 +19,7 @@ import { ProjectFileManager, ProjectFileFinder } from './createD365File.js';
 import { heuristicEdtBaseType } from './generateSmartTable.js';
 import { normalizeD365Xml } from '../utils/d365XmlNormalizer.js';
 import { upsertAxTableProperty, AX_TABLE_NON_EXISTENT_PROPERTIES, } from '../utils/axTablePropertyOrder.js';
+import { upsertAxFormDesignProperty } from '../utils/axFormDesignProperties.js';
 import { enforceGrounding } from '../utils/provenanceStore.js';
 import { gateOnReferenceErrors } from './resolveReferences.js';
 import { checkAddControlAgainstParentPattern, isFormPatternEnforceEnabled, } from './validateFormPattern.js';
@@ -303,6 +304,17 @@ async function directXmlModifyProperty(filePath, propertyPath, propertyValue) {
         const escapedValue = String(propertyValue)
             .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
         const tagName = propertyPath.split(/[./]/).pop();
+        // Forms first: the bridge refuses modify-property for AxForm entirely, and the
+        // generic path below cannot serve Design properties either — Caption/Style also
+        // occur on controls, so it sees several matches and refuses (#37).
+        const formPatched = upsertAxFormDesignProperty(content, tagName, escapedValue);
+        if (formPatched) {
+            await fs.writeFile(filePath, normalizeD365Xml(formPatched), 'utf-8');
+            return {
+                success: true,
+                message: `✅ Form Design property '${tagName}'='${propertyValue}' set via direct XML (the bridge does not support modify-property for forms). File: ${filePath}`,
+            };
+        }
         const openTagRe = new RegExp(`<${tagName}\\b[^>]*>[\\s\\S]*?</${tagName}>`, 'g');
         const selfClosingRe = new RegExp(`<${tagName}\\b([^>]*)/>`, 'g');
         const openMatches = content.match(openTagRe) ?? [];
@@ -608,6 +620,71 @@ async function directXmlAddIndex(filePath, indexName, fields, allowDuplicates, a
         return null;
     }
 }
+/** DeleteAction values accepted by the AxTable serialiser. */
+export const DELETE_ACTION_TYPES = ['None', 'Restricted', 'Cascade', 'CascadeRestricted'];
+/**
+ * add-delete-action / remove-delete-action on a TABLE, written straight to the XML.
+ *
+ * There is no bridge operation for DeleteActions at all (finding #36), so a
+ * cascading delete action was inexpressible through the modify surface — the only
+ * route was the forbidden whole-file overwrite. <DeleteActions> is a collection
+ * sibling, not part of the order-sensitive top-level property block, so patching
+ * it in place is safe. Shape matches MetadataWriteService.cs: Name, Table,
+ * DeleteAction.
+ */
+async function directXmlDeleteAction(filePath, mode, name, table, deleteAction) {
+    try {
+        const rawContent = await fs.readFile(filePath, 'utf-8');
+        const content = rawContent.replace(/^/, '').replace(/\r\n/g, '\n');
+        // Only tables carry <DeleteActions> — bail on any other shape so a mis-typed
+        // objectType never corrupts a non-table file.
+        if (!/<AxTable\b/.test(content))
+            return null;
+        const blockRe = new RegExp(`[\\t ]*<AxTableDeleteAction>\\s*<Name>${escapeRegExp(name)}</Name>[\\s\\S]*?</AxTableDeleteAction>\\n?`);
+        const existing = blockRe.exec(content);
+        if (mode === 'remove') {
+            if (!existing) {
+                return { success: true, message: `✅ Delete action '${name}' not present in ${filePath} — nothing to remove.` };
+            }
+            const updated = content.replace(blockRe, '');
+            await fs.writeFile(filePath, normalizeD365Xml(updated), 'utf-8');
+            return { success: true, message: `✅ Delete action '${name}' removed. File: ${filePath}` };
+        }
+        if (existing) {
+            return { success: true, message: `✅ Delete action '${name}' already present in ${filePath} — skipped (idempotent).` };
+        }
+        const newElement = `\t\t<AxTableDeleteAction>\n` +
+            `\t\t\t<Name>${name}</Name>\n` +
+            `\t\t\t<Table>${table ?? name}</Table>\n` +
+            `\t\t\t<DeleteAction>${deleteAction ?? 'Restricted'}</DeleteAction>\n` +
+            `\t\t</AxTableDeleteAction>`;
+        let updated;
+        if (content.includes('<DeleteActions />')) {
+            updated = content.replace('<DeleteActions />', `<DeleteActions>\n${newElement}\n\t</DeleteActions>`);
+        }
+        else if (content.includes('</DeleteActions>')) {
+            updated = content.replace('</DeleteActions>', `${newElement}\n\t</DeleteActions>`);
+        }
+        else {
+            // No <DeleteActions> collection at all — not a shape we can safely patch.
+            return null;
+        }
+        if (updated === content)
+            return null;
+        await fs.writeFile(filePath, normalizeD365Xml(updated), 'utf-8');
+        return {
+            success: true,
+            message: `✅ Delete action '${name}' (${deleteAction ?? 'Restricted'} on ${table ?? name}) added. File: ${filePath}`,
+        };
+    }
+    catch (err) {
+        console.error(`[modify_d365fo_file] directXmlDeleteAction failed: ${err}`);
+        return null;
+    }
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 /**
  * Writes the relation properties the bridge drops into an <AxTableRelation>.
  *
@@ -749,6 +826,7 @@ const ModifyD365FileArgsSchema = z.object({
         'add-field', 'modify-field', 'rename-field', 'replace-all-fields', 'remove-field',
         'add-index', 'remove-index',
         'add-relation', 'remove-relation',
+        'add-delete-action', 'remove-delete-action',
         'add-field-group', 'remove-field-group', 'add-field-to-field-group',
         'add-field-modification',
         'add-data-source',
@@ -880,6 +958,10 @@ const ModifyD365FileArgsSchema = z.object({
     relationCardinality: z.string().optional().describe('Cardinality on local side: ZeroMore | ZeroOne | ExactlyOne (default: ZeroMore).'),
     relatedTableCardinality: z.string().optional().describe('Cardinality on related side: ZeroMore | ZeroOne | ExactlyOne (default: ExactlyOne).'),
     relationshipType: z.string().optional().describe('Relationship type: Association | Composition | Aggregation | Link | Specialization (default: Association).'),
+    // For add-delete-action / remove-delete-action (table)
+    deleteActionTable: z.string().optional().describe('Related table the delete action applies to (e.g. "SalesLine"). Defaults to deleteActionName.'),
+    deleteActionName: z.string().optional().describe('Delete action name — conventionally the related table name. Required for both add- and remove-delete-action.'),
+    deleteActionType: z.enum(DELETE_ACTION_TYPES).optional().describe('None | Restricted (default) | Cascade | CascadeRestricted.'),
     // For add-field-group / remove-field-group / add-field-to-field-group (table, table-extension)
     fieldGroupName: z.string().optional().describe('Field group name. For add-field-to-field-group in a table-extension: name of the group (new or existing base-table group).'),
     fieldGroupFields: z.array(z.string()).optional().describe('Initial field names for add-field-group. Can be empty — add fields later with add-field-to-field-group.'),
@@ -1464,6 +1546,15 @@ export async function modifyD365FileTool(request, context) {
                     }
                     break;
                 }
+                case 'add-delete-action':
+                case 'remove-delete-action': {
+                    // No bridge op exists for DeleteActions (#36) — this is the only path.
+                    const daName = args.deleteActionName ?? args.deleteActionTable;
+                    if (daName) {
+                        bridgeResult = await directXmlDeleteAction(actualFilePath, operation === 'add-delete-action' ? 'add' : 'remove', daName, args.deleteActionTable, args.deleteActionType);
+                    }
+                    break;
+                }
                 case 'add-field-group': {
                     if (args.fieldGroupName) {
                         bridgeResult = await bridgeAddFieldGroup(context.bridge, objectName, args.fieldGroupName, args.fieldGroupLabel, args.fieldGroupFields);

package/dist/tools/validateXpp.js

@@ -443,8 +443,9 @@ function checkGenericDocComment(code) {
 }
 /**
  * XML001 — AxTable XML missing an index with <AlternateKey>Yes</AlternateKey>.
- * Every D365FO table must have at least one index marked as alternate key
- * for the BPCheckAlternateKeyAbsent rule.
+ * Warning, not error: xppbp raises BPCheckAlternateKeyAbsent as a warning and the
+ * table still builds. As an error it made a legitimately single-index table
+ * unsatisfiable (eval #7).
  */
 function checkMissingAlternateKey(code) {
     const violations = [];
@@ -458,12 +459,11 @@ function checkMissingAlternateKey(code) {
     if (!/<AlternateKey>\s*Yes\s*<\/AlternateKey>/i.test(code)) {
         violations.push({
             rule: 'XML001',
-            severity: 'error',
+            severity: 'warning',
             excerpt: '<AxTable> — no index with <AlternateKey>Yes</AlternateKey>',
-            fix: 'Add at least one <AxTableIndex> with <AlternateKey>Yes</AlternateKey>. ' +
-                'D365FO requires every table to have an alternate key index ' +
-                '(BPCheckAlternateKeyAbsent). ' +
-                'generate_smart adds this automatically via buildPrimaryKeyIndex.',
+            fix: 'Add an <AxTableIndex> with <AlternateKey>Yes</AlternateKey> unless the table ' +
+                'deliberately has none — xppbp reports BPCheckAlternateKeyAbsent as a warning and ' +
+                'the table still builds. generate_smart adds one via buildPrimaryKeyIndex.',
         });
     }
     return violations;

package/dist/utils/axFormDesignProperties.d.ts

@@ -0,0 +1,25 @@
+/**
+ * AxForm <Design> property upsert.
+ *
+ * The C# bridge rejects modify-property for forms outright ("modify-property not
+ * supported for objectType form via bridge"), so the Design annotations
+ * object_patterns(action="spec") prescribes — Pattern / PatternVersion / Style —
+ * could not be set through any grounded path (findings #37, corpus
+ * 2026-07-22T04__L2-form-over-view). The generic directXmlModifyProperty cannot
+ * serve them either: Caption/Style also occur on controls, so it sees several
+ * matches and refuses to guess.
+ *
+ * Ground truth for shape and order: eval/goldens/L1-form-listpage (VM-captured,
+ * built clean) — Design's direct-child properties carry `xmlns=""`, are
+ * alphabetical, and <Controls> terminates the block.
+ */
+/** Direct-child properties of <Design> the serialiser writes. */
+export declare const AX_FORM_DESIGN_PROPERTIES: Set<string>;
+/**
+ * Set a form Design property, inserting it in alphabetical order when absent.
+ * Returns the updated XML, or null when the document is not an AxForm, has no
+ * <Design>, or the property is not a Design property (so the caller can surface
+ * the original error rather than write something invented).
+ */
+export declare function upsertAxFormDesignProperty(xml: string, property: string, value: string): string | null;
+//# sourceMappingURL=axFormDesignProperties.d.ts.map

package/dist/utils/axFormDesignProperties.js

@@ -0,0 +1,78 @@
+/**
+ * AxForm <Design> property upsert.
+ *
+ * The C# bridge rejects modify-property for forms outright ("modify-property not
+ * supported for objectType form via bridge"), so the Design annotations
+ * object_patterns(action="spec") prescribes — Pattern / PatternVersion / Style —
+ * could not be set through any grounded path (findings #37, corpus
+ * 2026-07-22T04__L2-form-over-view). The generic directXmlModifyProperty cannot
+ * serve them either: Caption/Style also occur on controls, so it sees several
+ * matches and refuses to guess.
+ *
+ * Ground truth for shape and order: eval/goldens/L1-form-listpage (VM-captured,
+ * built clean) — Design's direct-child properties carry `xmlns=""`, are
+ * alphabetical, and <Controls> terminates the block.
+ */
+/** Direct-child properties of <Design> the serialiser writes. */
+export const AX_FORM_DESIGN_PROPERTIES = new Set([
+    'Caption',
+    'ColumnsMode',
+    'DataSource',
+    'Pattern',
+    'PatternVersion',
+    'ShowDeleteButton',
+    'ShowNewButton',
+    'Style',
+    'TitleDataSource',
+    'ViewEditMode',
+    'WindowResize',
+    'WindowType',
+]);
+/**
+ * Set a form Design property, inserting it in alphabetical order when absent.
+ * Returns the updated XML, or null when the document is not an AxForm, has no
+ * <Design>, or the property is not a Design property (so the caller can surface
+ * the original error rather than write something invented).
+ */
+export function upsertAxFormDesignProperty(xml, property, value) {
+    if (!/<AxForm[\s>]/.test(xml))
+        return null;
+    if (!AX_FORM_DESIGN_PROPERTIES.has(property))
+        return null;
+    const designStart = xml.search(/^[ \t]*<Design>/m);
+    if (designStart === -1)
+        return null;
+    const designOpen = xml.indexOf('>', designStart) + 1;
+    // Everything before <Controls> (or </Design> on a control-less form) is the
+    // direct-child property region — nested controls carry their own Caption/Style,
+    // and must never be touched.
+    const controlsRel = xml.slice(designOpen).search(/^[ \t]*<Controls[ />]/m);
+    const endRel = controlsRel !== -1 ? controlsRel : xml.slice(designOpen).search(/^[ \t]*<\/Design>/m);
+    if (endRel === -1)
+        return null;
+    const propsEnd = designOpen + endRel;
+    const head = xml.slice(0, designOpen);
+    const region = xml.slice(designOpen, propsEnd);
+    const tail = xml.slice(propsEnd);
+    const designIndent = /^([ \t]*)<Design>/m.exec(xml.slice(designStart))?.[1] ?? '\t';
+    const indent = `${designIndent}\t`;
+    const element = `${indent}<${property} xmlns="">${value}</${property}>\n`;
+    const existing = new RegExp(`^[ \\t]*<${property}\\b[^>]*?/>[ \\t]*\\n|^[ \\t]*<${property}\\b[^>]*>[\\s\\S]*?</${property}>[ \\t]*\\n`, 'm');
+    if (existing.test(region)) {
+        return head + region.replace(existing, element) + tail;
+    }
+    // Insert before the first existing property that sorts after this one.
+    const propLine = /^[ \t]*<([A-Za-z_][\w.-]*)\b/gm;
+    let insertAt = null;
+    for (let m = propLine.exec(region); m; m = propLine.exec(region)) {
+        if (AX_FORM_DESIGN_PROPERTIES.has(m[1]) && m[1].localeCompare(property) > 0) {
+            insertAt = m.index;
+            break;
+        }
+    }
+    const patched = insertAt === null
+        ? region.replace(/\s*$/, '\n') + element
+        : region.slice(0, insertAt) + element + region.slice(insertAt);
+    return head + patched + tail;
+}
+//# sourceMappingURL=axFormDesignProperties.js.map

package/dist/utils/loadEnv.d.ts

@@ -10,6 +10,8 @@
  *      caller picked on purpose)
  *   3. config/d365fo-mcp.json + config/secrets.json
  *   4. the ambient repo-root .env (pre-wizard installations keep working)
+ *   5. the built-in defaults for path settings, resolved against the
+ *      installation directory (see defaultPathEnv)
  *
  * Multiple instances run from one source folder by pointing each at its own
  * config or .env file:

package/dist/utils/loadEnv.js

@@ -10,6 +10,8 @@
  *      caller picked on purpose)
  *   3. config/d365fo-mcp.json + config/secrets.json
  *   4. the ambient repo-root .env (pre-wizard installations keep working)
+ *   5. the built-in defaults for path settings, resolved against the
+ *      installation directory (see defaultPathEnv)
  *
  * Multiple instances run from one source folder by pointing each at its own
  * config or .env file:
@@ -25,7 +27,7 @@ import dotenv from 'dotenv';
 import { existsSync } from 'fs';
 import { dirname, isAbsolute, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
-import { resolveConfigFiles, toEnvRecord } from '../config/configFile.js';
+import { defaultPathEnv, resolveConfigFiles, toEnvRecord } from '../config/configFile.js';
 /** Env vars whose relative paths should resolve from the .env file directory. */
 const PATH_VARS = ['DB_PATH', 'LABELS_DB_PATH', 'METADATA_PATH'];
 /**
@@ -109,6 +111,14 @@ export function loadEnv(callerImportMetaUrl) {
         if (!fromRealEnv.has(key) && !pinnedByEnvFile.has(key))
             process.env[key] = value;
     }
+    // Lowest precedence of all: the defaults for the path settings nobody writes
+    // out, anchored to the installation directory rather than process.cwd(). See
+    // defaultPathEnv — without this the index of an npm install is built beside
+    // the package instead of in the directory chosen during setup.
+    for (const [key, value] of Object.entries(defaultPathEnv(files.baseDir))) {
+        if (!process.env[key])
+            process.env[key] = value;
+    }
     // Bridge the public D365FO_-prefixed setting name to the internal
     // DEV_ENVIRONMENT_TYPE that consumers read. Prefixed wins when both are set;
     // a lone plain entry is tolerated for backward compatibility.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "d365fo-mcp",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "MCP Server for X++ Code Completion in D365 Finance & Operations",
   "type": "module",
   "main": "dist/index.js",