d365fo-mcp 1.8.2 → 1.8.3

package/dist/tools/modifyD365File.js

@@ -28,6 +28,7 @@ import { validateEdtExtensionChange } from '../utils/edtExtensionValidator.js';
 import { lintXppSelect } from '../utils/xppSelectLint.js';
 import { getRequiredParams, renderOpSpec, OP_PARAM_ALIASES, findIgnoredParams, renderIgnoredParamsWarning, findMissingMutationParams, } from './d365foFileOpSpecs.js';
 import { lookupSymbolNocase } from '../utils/symbolLookup.js';
+import { crossModelWriteRefusal, baseObjectOf, } from '../utils/crossModelWriteGuard.js';
 /**
  * Decode the standard XML entities (<, >, ', ", &) and normalise
  * line endings by stripping xml2js's 
 representation of carriage return.
@@ -1449,6 +1450,26 @@ export async function modifyD365FileTool(request, context) {
                     `  • Form:  d365fo_file(action="create", objectType="form-extension", objectName="${objectName}.${configuredModel || 'YourModel'}Extension")`);
             }
         }
+        // 1c. Cross-model guard: the object is custom, but owned by a DIFFERENT custom
+        // model than the one this workspace targets (shared "Core" model vs. the country
+        // model that extends it). Editing it in place silently changes code the active
+        // model only consumes — the wanted change is an extension in the active model.
+        // Ownership comes from the path's <Model> segment, not the <Package> segment
+        // used above: one package can carry several models.
+        const owningModel = containment.modelSegment ?? null;
+        const activeModel = getConfigManager().getModelName() ?? '';
+        const crossModelRefusal = crossModelWriteRefusal({
+            objectName,
+            objectType,
+            owningModel,
+            owningPackage: containment.packageSegment ?? resolvedModelFromPath,
+            activeModel,
+            explicitModelName: modelName,
+            existingExtensions: findExtensionsInModel(symbolIndex, baseObjectOf(objectName, objectType), activeModel),
+        });
+        if (crossModelRefusal) {
+            throw new Error(crossModelRefusal);
+        }
         // 2. Resolve actual XML file path (DB may store JSON metadata with sourcePath)
         let actualFilePath = filePath;
         try {
@@ -1516,7 +1537,11 @@ export async function modifyD365FileTool(request, context) {
         // spells this out ("Fields in extensions → {Prefix}{FieldName}") and BP
         // rejects the unprefixed form. This is applied once, here, so every writer
         // below (bridge op and direct-XML fallback alike) sees the final name.
-        const memberPrefixNote = applyExtensionMemberPrefix(args, objectType, operation, resolvedModelFromPath || modelName || getConfigManager().getModelName() || '');
+        const memberPrefixNote = applyExtensionMemberPrefix(args, objectType, operation, 
+        // The MODEL segment, not the package: members added to an extension must
+        // carry the prefix of the model that owns the extension file (ContosoFinanceSK
+        // → ContosoSK_), and a package can hold a model whose prefix differs.
+        containment.modelSegment || resolvedModelFromPath || modelName || getConfigManager().getModelName() || '');
         if (memberPrefixNote)
             generationNote += memberPrefixNote;
         let bridgeResult = null;
@@ -2218,6 +2243,34 @@ const EXTENSION_MEMBER_NAME_ARG = {
     'add-field-group': 'fieldGroupName',
     'add-enum-value': 'enumValueName',
 };
+/**
+ * Extensions of `baseObject` that already live in `model` — so the cross-model
+ * refusal can point at the extension the active model ALREADY has instead of
+ * telling the agent to create a second one next to it.
+ *
+ * Reads `extension_metadata`, which is indexed on base_object_name and small
+ * enough that COLLATE NOCASE here costs nothing (unlike the 1M-row symbols
+ * table). Best-effort: a missing table or unbuilt index yields no suggestions,
+ * never an error — the refusal itself does not depend on it.
+ */
+function findExtensionsInModel(symbolIndex, baseObject, model) {
+    if (!baseObject || !model)
+        return [];
+    try {
+        const rdb = symbolIndex?.getReadDb?.();
+        if (!rdb)
+            return [];
+        const rows = rdb.prepare(`SELECT extension_name AS name, extension_type AS type
+         FROM extension_metadata
+        WHERE base_object_name = ? COLLATE NOCASE
+          AND model = ? COLLATE NOCASE
+        LIMIT 5`).all(baseObject, model);
+        return rows ?? [];
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * Prefix the new member name this operation carries, when writing into an
  * extension. Mutates `args` in place and returns a note for the response (empty

package/dist/tools/validateObjectNaming.js

@@ -4,7 +4,7 @@
  * detect conflicts against the symbol index, and suggest correct names.
  */
 import { z } from 'zod';
-import { getObjectSuffix, getExtensionNamingStyle } from '../utils/modelClassifier.js';
+import { getObjectSuffix, getExtensionNamingStyle, resolveObjectPrefix, deriveExtensionInfix, } from '../utils/modelClassifier.js';
 import { getConfigManager } from '../utils/configManager.js';
 import { lookupSymbolNocase, lookupSymbolsNocase } from '../utils/symbolLookup.js';
 const ValidateObjectNamingArgsSchema = z.object({
@@ -46,26 +46,25 @@ export async function validateObjectNamingTool(request, context) {
         else if (name.length > 70) {
             warnings.push(`Name is ${name.length} characters — approaching the ${MAX_NAME_LENGTH}-char AOT limit. Consider a shorter name to leave room for extensions.`);
         }
-        // Resolve model prefix: explicit arg → EXTENSION_PREFIX env → DB auto-detect (mirrors resolveObjectPrefix()).
-        let prefix = args.modelPrefix?.toUpperCase() || '';
-        if (!prefix) {
-            const envPrefix = process.env.EXTENSION_PREFIX?.trim().replace(/_+$/, '');
-            if (envPrefix) {
-                prefix = envPrefix.toUpperCase();
-            }
-            else {
-                prefix = detectModelPrefix(db, name);
-            }
-        }
-        // Under EXTENSION_NAMING_STYLE=model-name the extension token is the model name (Visual Studio
-        // default) rather than the prefix infix: class extension → {Base}_{ModelName}_Extension,
-        // element extension → {Base}.{ModelName}. Explicit modelName arg wins over workspace config.
+        // The model whose convention is being validated against: explicit arg, else the
+        // model this workspace targets. It decides the prefix, so it is resolved BEFORE
+        // the prefix — a workspace on ContosoFinanceSK must validate against ContosoSK even
+        // when EXTENSION_PREFIX still says something else.
         const namingStyle = getExtensionNamingStyle();
-        let modelName = args.modelName?.trim() || '';
-        if (!modelName && namingStyle === 'model-name') {
-            modelName = getConfigManager().getModelName() ?? '';
-        }
+        const modelName = args.modelName?.trim() || getConfigManager().getModelName() || '';
         const useModelName = namingStyle === 'model-name' && !!modelName;
+        // Resolve model prefix: explicit arg → the active model's own prefix
+        // (resolveObjectPrefix: learned from that model's objects, else EXTENSION_PREFIX,
+        // else the model name) → DB auto-detect for an unconfigured workspace.
+        // NOT upper-cased: "ContosoFin" is a PascalCase prefix, and "CONTOSOFIN" would make every
+        // suggested name and every startsWith() check below wrong.
+        let prefix = args.modelPrefix?.trim() || '';
+        if (!prefix) {
+            prefix = resolveObjectPrefix(modelName) || detectModelPrefix(db, name);
+        }
+        // Token embedded in extension element/class names — the model's own infix when its
+        // existing extensions state one (ContosoFinanceSK → "ContosoSK"), else derived.
+        const extensionInfix = prefix ? deriveExtensionInfix(prefix, modelName) : '';
         // Rule set 1: extension naming rules
         if (isExtension) {
             const baseObjectName = args.baseObjectName;
@@ -77,8 +76,8 @@ export async function validateObjectNamingTool(request, context) {
                     // prefix style → {Base}{Prefix}_Extension; model-name style → {Base}_{ModelName}_Extension
                     const expectedPattern = useModelName
                         ? `${baseObjectName}_${modelName}_Extension`
-                        : `${baseObjectName}${prefix}_Extension`;
-                    const expectedToken = useModelName ? modelName : prefix;
+                        : `${baseObjectName}${extensionInfix}_Extension`;
+                    const expectedToken = useModelName ? modelName : extensionInfix;
                     if (!name.startsWith(baseObjectName)) {
                         errors.push(`Class extension names must start with the base class name.\n  Expected format: ${expectedPattern}`);
                         if (expectedToken)
@@ -98,12 +97,12 @@ export async function validateObjectNamingTool(request, context) {
                             !middle.toLowerCase().includes(expectedToken.toLowerCase())) {
                             warnings.push(useModelName
                                 ? `Extension name does not embed the model name "${modelName}" (EXTENSION_NAMING_STYLE=model-name).\n  Current: ${name}\n  Recommended: ${expectedPattern}`
-                                : `Extension name does not include model prefix "${prefix}".\n  Current: ${name}\n  Recommended: ${expectedPattern}`);
+                                : `Extension name does not include model "${modelName || '(unknown)'}"'s extension infix "${extensionInfix}".\n  Current: ${name}\n  Recommended: ${expectedPattern}`);
                         }
                     }
                     suggestions.push(useModelName
                         ? `AOT name for an element extension instead: ${baseObjectName}.${modelName}`
-                        : `AOT label for extension file: ${baseObjectName}.${prefix}Extension (if creating table-extension AOT object instead)`);
+                        : `AOT label for extension file: ${baseObjectName}.${extensionInfix}Extension (if creating table-extension AOT object instead)`);
                 }
                 else if (useModelName) {
                     // AOT extensions (table/form/enum/edt), model-name style: {Base}.{ModelName} — bare model
@@ -124,8 +123,8 @@ export async function validateObjectNamingTool(request, context) {
                     }
                 }
                 else {
-                    // AOT extensions (table/form/enum/edt), prefix style: {Base}.{Prefix}Extension.
-                    const expectedPattern = `${baseObjectName}.${prefix}Extension`;
+                    // AOT extensions (table/form/enum/edt), prefix style: {Base}.{Infix}Extension.
+                    const expectedPattern = `${baseObjectName}.${extensionInfix}Extension`;
                     if (!name.includes('.')) {
                         errors.push(`${args.objectType} names must use dot notation: {Base}.{Prefix}Extension.\n  Expected: ${expectedPattern}`);
                         if (prefix)
@@ -137,10 +136,10 @@ export async function validateObjectNamingTool(request, context) {
                             errors.push(`Extension base (before '.') must exactly match baseObjectName.\n  Expected: ${baseObjectName}.xxx\n  Got: ${basePart}.xxx`);
                         }
                         if (!extPart.endsWith('Extension')) {
-                            errors.push(`Extension suffix (after '.') must end with 'Extension'.\n  Expected: ${prefix}Extension\n  Got: ${extPart}`);
+                            errors.push(`Extension suffix (after '.') must end with 'Extension'.\n  Expected: ${extensionInfix}Extension\n  Got: ${extPart}`);
                         }
-                        else if (prefix && !extPart.startsWith(prefix)) {
-                            warnings.push(`Extension suffix should start with model prefix "${prefix}".\n  Current: ${extPart}\n  Recommended: ${prefix}Extension`);
+                        else if (extensionInfix && !extPart.toLowerCase().startsWith(extensionInfix.toLowerCase())) {
+                            warnings.push(`Extension suffix should start with model "${modelName || '(unknown)'}"'s infix "${extensionInfix}".\n  Current: ${extPart}\n  Recommended: ${extensionInfix}Extension`);
                         }
                     }
                 }
@@ -173,7 +172,7 @@ export async function validateObjectNamingTool(request, context) {
                 }
             }
             if (prefix) {
-                if (!name.startsWith(prefix) && !name.toUpperCase().startsWith(prefix)) {
+                if (!name.toLowerCase().startsWith(prefix.toLowerCase())) {
                     warnings.push(`Proposed name does not start with model prefix "${prefix}". All custom objects should be prefixed to avoid conflicts.`);
                     suggestions.push(`Prefixed name: ${prefix}${name}`);
                 }
@@ -220,12 +219,13 @@ export async function validateObjectNamingTool(request, context) {
         let output = `Validation: "${name}" as ${args.objectType}\n`;
         if (args.baseObjectName)
             output += `Base Object: ${args.baseObjectName}\n`;
-        if (prefix)
-            output += `Model Prefix: ${prefix}\n`;
+        if (prefix) {
+            output += `Model Prefix: ${prefix}${modelName ? ` (model ${modelName})` : ''}\n`;
+        }
         if (isExtension) {
             output += useModelName
                 ? `Extension Style: model-name (token = model name "${modelName}")\n`
-                : `Extension Style: prefix (token = model prefix infix)\n`;
+                : `Extension Style: prefix (token = "${extensionInfix}")\n`;
             if (namingStyle === 'model-name' && !modelName) {
                 output += `  ⚠ EXTENSION_NAMING_STYLE=model-name but no model name could be resolved — validated structure only. Pass modelName to validate the extension token.\n`;
             }

package/dist/utils/crossModelWriteGuard.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Cross-model write guard.
+ *
+ * `modify` already refuses to touch objects in standard Microsoft models
+ * (isStandardModel), but that check says nothing about the far more common
+ * real-world layout: a customer solution split across several CUSTOM models,
+ * e.g. a shared `ContosoFinanceCore` plus country models `ContosoFinanceSK` /
+ * `ContosoFinanceCZ` that extend it. The workspace's .rnrproj names exactly ONE of
+ * them as the target model; every other model is somebody else's code as far as
+ * this workspace is concerned.
+ *
+ * Without this guard the failure is silent and expensive: asked to "add a field
+ * to <table>", the agent resolves the table by name, lands in the shared model
+ * that happens to own it, and edits it in place. The field is then invisible in
+ * the active model's project and version control, and it lands in code every
+ * other country model inherits — instead of the one thing that was wanted, a
+ * table extension in the active model.
+ *
+ * So a write whose resolved file lives in a model other than the active one is
+ * refused by default, with the extension route spelled out. Two deliberate
+ * escape hatches, mirroring the standard-model guard's "explicit modelName =
+ * you know what you're doing":
+ *   - `modelName="<owning model>"` on the call — a per-call, per-model opt-in,
+ *   - `D365FO_ALLOW_CROSS_MODEL_WRITE=true` — an environment-wide opt-out for
+ *     setups where one server really does serve several models.
+ */
+/** An extension of the target object that already exists in the active model. */
+export interface ExistingExtension {
+    name: string;
+    type: string;
+}
+export interface CrossModelWriteCheck {
+    /** Object being written, as resolved (may already be an extension). */
+    objectName: string;
+    /** d365fo_file objectType, e.g. 'table', 'table-extension', 'class'. */
+    objectType: string;
+    /** Model that owns the resolved file (the `<Model>` path segment). */
+    owningModel: string | null | undefined;
+    /**
+     * `<Package>` segment of the same path. A match on EITHER segment counts as
+     * "same model": most custom models sit in a package of the same name, but a
+     * configured model name occasionally matches only the package (several models
+     * in one package, or a model folder named after the package). Accepting both
+     * keeps the guard from firing on the workspace's own objects.
+     */
+    owningPackage?: string | null;
+    /** Model the workspace targets (.rnrproj / D365FO_MODEL_NAME). */
+    activeModel: string | null | undefined;
+    /** `modelName` as passed by the caller — the per-call opt-in. */
+    explicitModelName?: string | null;
+    /** Extensions of the base object that already exist in the active model. */
+    existingExtensions?: ExistingExtension[];
+}
+/** The base object an extension extends: "CustTable.FooExtension" → "CustTable". */
+export declare function baseObjectOf(objectName: string, objectType: string): string;
+/**
+ * The name the extension WOULD get in `activeModel`, following that model's own
+ * naming (prefix inference + EXTENSION_NAMING_STYLE), or null when the type has
+ * no extension form. Class extensions use the `{Base}{Infix}_Extension` shape;
+ * everything else the dot-notation element form.
+ */
+export declare function suggestedExtensionName(baseObject: string, baseType: string, activeModel: string): string | null;
+/**
+ * Refusal message for a write into a model other than the active one, or null
+ * when the write is allowed.
+ */
+export declare function crossModelWriteRefusal(check: CrossModelWriteCheck): string | null;
+//# sourceMappingURL=crossModelWriteGuard.d.ts.map

package/dist/utils/crossModelWriteGuard.js

@@ -0,0 +1,122 @@
+/**
+ * Cross-model write guard.
+ *
+ * `modify` already refuses to touch objects in standard Microsoft models
+ * (isStandardModel), but that check says nothing about the far more common
+ * real-world layout: a customer solution split across several CUSTOM models,
+ * e.g. a shared `ContosoFinanceCore` plus country models `ContosoFinanceSK` /
+ * `ContosoFinanceCZ` that extend it. The workspace's .rnrproj names exactly ONE of
+ * them as the target model; every other model is somebody else's code as far as
+ * this workspace is concerned.
+ *
+ * Without this guard the failure is silent and expensive: asked to "add a field
+ * to <table>", the agent resolves the table by name, lands in the shared model
+ * that happens to own it, and edits it in place. The field is then invisible in
+ * the active model's project and version control, and it lands in code every
+ * other country model inherits — instead of the one thing that was wanted, a
+ * table extension in the active model.
+ *
+ * So a write whose resolved file lives in a model other than the active one is
+ * refused by default, with the extension route spelled out. Two deliberate
+ * escape hatches, mirroring the standard-model guard's "explicit modelName =
+ * you know what you're doing":
+ *   - `modelName="<owning model>"` on the call — a per-call, per-model opt-in,
+ *   - `D365FO_ALLOW_CROSS_MODEL_WRITE=true` — an environment-wide opt-out for
+ *     setups where one server really does serve several models.
+ */
+import { resolveObjectPrefix, applyObjectPrefix } from './modelClassifier.js';
+/** Base object type → the d365fo_file objectType used to extend it. */
+const EXTENSION_TYPE_OF = {
+    table: 'table-extension',
+    form: 'form-extension',
+    enum: 'enum-extension',
+    edt: 'edt-extension',
+    view: 'view-extension',
+    query: 'query-extension',
+    map: 'map-extension',
+    'data-entity': 'data-entity-extension',
+    menu: 'menu-extension',
+    class: 'class-extension',
+};
+function eq(a, b) {
+    return !!a && !!b && a.trim().toLowerCase() === b.trim().toLowerCase();
+}
+/** True when the operator has opted out of the guard environment-wide. */
+function guardDisabled() {
+    const v = process.env.D365FO_ALLOW_CROSS_MODEL_WRITE?.trim().toLowerCase();
+    return v === 'true' || v === '1' || v === 'yes';
+}
+/** The base object an extension extends: "CustTable.FooExtension" → "CustTable". */
+export function baseObjectOf(objectName, objectType) {
+    if (objectName.includes('.'))
+        return objectName.slice(0, objectName.indexOf('.'));
+    if (objectType === 'class-extension' && objectName.endsWith('_Extension')) {
+        return objectName.slice(0, -'_Extension'.length);
+    }
+    return objectName;
+}
+/**
+ * The name the extension WOULD get in `activeModel`, following that model's own
+ * naming (prefix inference + EXTENSION_NAMING_STYLE), or null when the type has
+ * no extension form. Class extensions use the `{Base}{Infix}_Extension` shape;
+ * everything else the dot-notation element form.
+ */
+export function suggestedExtensionName(baseObject, baseType, activeModel) {
+    if (!EXTENSION_TYPE_OF[baseType])
+        return null;
+    const prefix = resolveObjectPrefix(activeModel);
+    if (!prefix)
+        return null;
+    return baseType === 'class'
+        ? applyObjectPrefix(`${baseObject}_Extension`, prefix, activeModel)
+        : applyObjectPrefix(`${baseObject}.Extension`, prefix, activeModel);
+}
+/**
+ * Refusal message for a write into a model other than the active one, or null
+ * when the write is allowed.
+ */
+export function crossModelWriteRefusal(check) {
+    const { objectName, objectType, owningModel, activeModel, explicitModelName } = check;
+    // Nothing to compare against — an unconfigured workspace or a path whose model
+    // segment could not be determined. Never block on a guess.
+    if (!owningModel || !activeModel)
+        return null;
+    if (eq(owningModel, activeModel) || eq(check.owningPackage, activeModel))
+        return null;
+    // Per-call opt-in: the caller named the owning model (or its package) outright.
+    if (eq(explicitModelName, owningModel) || eq(explicitModelName, check.owningPackage))
+        return null;
+    if (guardDisabled()) {
+        console.error(`[crossModelWriteGuard] D365FO_ALLOW_CROSS_MODEL_WRITE — allowing write to "${objectName}" ` +
+            `in model "${owningModel}" (active model "${activeModel}")`);
+        return null;
+    }
+    const isExtension = objectType.endsWith('-extension');
+    const baseObject = baseObjectOf(objectName, objectType);
+    const baseType = isExtension ? objectType.slice(0, -'-extension'.length) : objectType;
+    const extType = EXTENSION_TYPE_OF[baseType];
+    const lines = [
+        `⛔ Refusing to modify "${objectName}" — it belongs to model "${owningModel}", ` +
+            `not to this workspace's model "${activeModel}".`,
+        '',
+        `"${owningModel}" is a different model: the change would land in code that "${activeModel}" ` +
+            `only consumes, it would not appear in this workspace's project or version control, and every ` +
+            `other model built on "${owningModel}" would inherit it.`,
+        '',
+    ];
+    if (extType) {
+        const existing = (check.existingExtensions ?? []).filter(e => !eq(e.name, objectName));
+        lines.push(`Extend it from "${activeModel}" instead:`);
+        if (existing.length > 0) {
+            lines.push(`  • "${activeModel}" already extends ${baseObject} — add to that extension:`, ...existing.slice(0, 5).map(e => `      d365fo_file(action="modify", objectType="${extType}", objectName="${e.name}", modelName="${activeModel}", operation=…)`));
+        }
+        else {
+            const suggested = suggestedExtensionName(baseObject, baseType, activeModel);
+            lines.push(`  • no extension of ${baseObject} exists in "${activeModel}" yet — create one:`, `      d365fo_file(action="create", objectType="${extType}", objectName="${suggested ?? `${baseObject}.<Prefix>Extension`}", modelName="${activeModel}")`, `    then add the member to it with action="modify".`);
+        }
+        lines.push('');
+    }
+    lines.push(`If editing "${owningModel}" in place is genuinely what you want, say so explicitly:`, `  • pass modelName="${owningModel}" on this call, or`, `  • switch the workspace to that model: get_workspace_info(projectName="${owningModel}"), or`, `  • set D365FO_ALLOW_CROSS_MODEL_WRITE=true to disable this guard for the whole server.`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=crossModelWriteGuard.js.map

package/dist/utils/pathContainment.d.ts

@@ -24,6 +24,15 @@ export interface PathContainmentResult {
     canonicalPath?: string;
     /** Matched root (for diagnostics). */
     matchedRoot?: string;
+    /** `<Package>` segment of the canonical layout, when ok. */
+    packageSegment?: string;
+    /**
+     * `<Model>` segment of the canonical layout, when ok — the model that actually
+     * OWNS the file. Package and model differ whenever one package carries several
+     * models, so ownership decisions (see crossModelWriteGuard) must read this and
+     * not the package name.
+     */
+    modelSegment?: string;
 }
 /**
  * Validate that `filePath` points at a D365FO AOT file inside an allowed root

package/dist/utils/pathContainment.js

@@ -195,7 +195,7 @@ export async function assertWritePathAllowed(filePath, modelHint, opts) {
             reason: `Path does not match canonical AOT layout (<Package>/<Model>/Ax<Type>/<File>):\n  ${filePath}`,
         };
     }
-    const [, modelSeg, axFolder, lastSeg] = parts;
+    const [packageSeg, modelSeg, axFolder, lastSeg] = parts;
     if (!/^Ax[A-Z]/.test(axFolder)) {
         return {
             ok: false,
@@ -218,7 +218,13 @@ export async function assertWritePathAllowed(filePath, modelHint, opts) {
             };
         }
     }
-    return { ok: true, canonicalPath: canonical, matchedRoot };
+    return {
+        ok: true,
+        canonicalPath: canonical,
+        matchedRoot,
+        packageSegment: packageSeg,
+        modelSegment: modelSeg,
+    };
 }
 /** Throwing wrapper — convenient in tool handlers. */
 export async function ensureWritePathAllowed(filePath, modelHint, opts) {

package/package.json

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