@khester/dataverse-codegen 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1406 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "../../node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// ../api-client/dist/index.js
+var require_dist = __commonJS({
+  "../api-client/dist/index.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export(index_exports, {
+      FetchClient: () => FetchClient,
+      MockClient: () => MockClient,
+      XrmClient: () => XrmClient,
+      createClient: () => createClient2,
+      getEnvironmentInfo: () => getEnvironmentInfo
+    });
+    module.exports = __toCommonJS(index_exports);
+    var FetchClient = class {
+      constructor(baseUrl, token, logger) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.token = token;
+        this.log = logger ?? console;
+      }
+      /** Update the token (e.g., after refresh) */
+      setToken(token) {
+        this.token = token;
+      }
+      getHeaders() {
+        return {
+          "Authorization": `Bearer ${this.token}`,
+          "Content-Type": "application/json; charset=utf-8",
+          "Accept": "application/json",
+          "OData-MaxVersion": "4.0",
+          "OData-Version": "4.0",
+          "Prefer": 'odata.include-annotations="*"'
+        };
+      }
+      buildUrl(path2, id, options) {
+        let url = `${this.baseUrl}/api/data/v9.2/${path2}`;
+        if (id) {
+          url += `(${id.replace(/[{}]/g, "")})`;
+        }
+        if (options) {
+          url += options.startsWith("?") ? options : `?${options}`;
+        }
+        return url;
+      }
+      async handleResponse(response) {
+        if (!response.ok) {
+          let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+          try {
+            const errorBody = await response.json();
+            if (errorBody.error?.message) {
+              errorMessage = errorBody.error.message;
+            } else if (errorBody.Message) {
+              errorMessage = errorBody.Message;
+            }
+          } catch {
+          }
+          if (response.status === 401) {
+            errorMessage += " (Token may be expired)";
+          } else if (response.status === 403) {
+            errorMessage += " (Insufficient permissions)";
+          } else if (response.status === 404) {
+            errorMessage += " (Entity or record not found)";
+          }
+          throw new Error(errorMessage);
+        }
+        if (response.status === 204) {
+          return {};
+        }
+        return response.json();
+      }
+      /**
+       * GET a collection endpoint, following `@odata.nextLink` so wide results
+       * (e.g. an entity with hundreds of attributes, or large metadata sets) are
+       * not silently truncated at the server page cap.
+       */
+      async fetchAllPages(url) {
+        const out = [];
+        let next = url;
+        while (next) {
+          const response = await fetch(next, { method: "GET", headers: this.getHeaders() });
+          const page = await this.handleResponse(response);
+          if (page.value) out.push(...page.value);
+          next = page["@odata.nextLink"];
+        }
+        return out;
+      }
+      extractIdFromResponse(response, _entitySetName) {
+        const entityIdHeader = response.headers.get("OData-EntityId");
+        if (entityIdHeader) {
+          const match = entityIdHeader.match(/\(([0-9a-f-]+)\)/i);
+          if (match) return match[1];
+        }
+        return null;
+      }
+      // CRUD Operations
+      async retrieve(entitySetName, id, options) {
+        const url = this.buildUrl(entitySetName, id, options);
+        this.log.log(`[FetchClient] GET ${url}`);
+        const response = await fetch(url, { method: "GET", headers: this.getHeaders() });
+        return this.handleResponse(response);
+      }
+      async retrieveMultiple(entitySetName, options) {
+        const url = this.buildUrl(entitySetName, void 0, options);
+        this.log.log(`[FetchClient] GET ${url}`);
+        const response = await fetch(url, { method: "GET", headers: this.getHeaders() });
+        return this.handleResponse(response);
+      }
+      async create(entitySetName, data) {
+        const url = this.buildUrl(entitySetName);
+        this.log.log(`[FetchClient] POST ${url}`);
+        const response = await fetch(url, {
+          method: "POST",
+          headers: { ...this.getHeaders(), "Prefer": "return=representation" },
+          body: JSON.stringify(data)
+        });
+        if (!response.ok) {
+          return this.handleResponse(response);
+        }
+        const id = this.extractIdFromResponse(response, entitySetName);
+        if (id) return { id };
+        try {
+          const body = await response.json();
+          const primaryKey = entitySetName.slice(0, -1) + "id";
+          const recordId = body[primaryKey] || body.id;
+          if (recordId) return { id: recordId };
+        } catch {
+        }
+        throw new Error("Could not determine created record ID");
+      }
+      async update(entitySetName, id, data) {
+        const url = this.buildUrl(entitySetName, id);
+        this.log.log(`[FetchClient] PATCH ${url}`);
+        const response = await fetch(url, {
+          method: "PATCH",
+          headers: this.getHeaders(),
+          body: JSON.stringify(data)
+        });
+        await this.handleResponse(response);
+      }
+      async delete(entitySetName, id) {
+        const url = this.buildUrl(entitySetName, id);
+        this.log.log(`[FetchClient] DELETE ${url}`);
+        const response = await fetch(url, { method: "DELETE", headers: this.getHeaders() });
+        await this.handleResponse(response);
+      }
+      // Batch Operations
+      async batchDelete(entitySetName, ids) {
+        const succeeded = [];
+        const failed = [];
+        for (const id of ids) {
+          try {
+            await this.delete(entitySetName, id);
+            succeeded.push(id);
+          } catch (err) {
+            failed.push({ id, error: err instanceof Error ? err.message : "Delete failed" });
+          }
+        }
+        return { succeeded, failed };
+      }
+      async batchUpdate(entitySetName, records) {
+        const succeeded = [];
+        const failed = [];
+        for (const record of records) {
+          try {
+            await this.update(entitySetName, record.id, record.data);
+            succeeded.push(record.id);
+          } catch (err) {
+            failed.push({ id: record.id, error: err instanceof Error ? err.message : "Update failed" });
+          }
+        }
+        return { succeeded, failed };
+      }
+      async batchCreate(entitySetName, records) {
+        const succeeded = [];
+        const failed = [];
+        for (let i = 0; i < records.length; i++) {
+          try {
+            const result = await this.create(entitySetName, records[i]);
+            succeeded.push({ id: result.id, data: records[i] });
+          } catch (err) {
+            failed.push({ rowNumber: i + 1, error: err instanceof Error ? err.message : "Create failed" });
+          }
+        }
+        return { succeeded, failed };
+      }
+      // Metadata Operations
+      async getEntityDefinitions(filter) {
+        const selectFields = [
+          "LogicalName",
+          "EntitySetName",
+          "SchemaName",
+          "DisplayName",
+          "DisplayCollectionName",
+          "PrimaryIdAttribute",
+          "PrimaryNameAttribute",
+          "IsCustomEntity",
+          "IsActivity",
+          "IsValidForAdvancedFind",
+          "ObjectTypeCode"
+        ].join(",");
+        let options = `?$select=${selectFields}`;
+        if (filter) {
+          options += `&$filter=${encodeURIComponent(filter)}`;
+        }
+        const url = `${this.baseUrl}/api/data/v9.2/EntityDefinitions${options}`;
+        this.log.log(`[FetchClient] GET ${url}`);
+        return this.fetchAllPages(url);
+      }
+      async getAttributeMetadata(entityLogicalName, filter) {
+        const selectFields = [
+          "LogicalName",
+          "SchemaName",
+          "DisplayName",
+          "Description",
+          "AttributeType",
+          "AttributeTypeName",
+          "RequiredLevel",
+          "IsValidForRead",
+          "IsValidForCreate",
+          "IsValidForUpdate",
+          "IsPrimaryId",
+          "IsPrimaryName"
+        ].join(",");
+        const defaultFilter = "IsValidForRead eq true";
+        const combinedFilter = filter ? `${defaultFilter} and ${filter}` : defaultFilter;
+        const url = `${this.baseUrl}/api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')/Attributes?$select=${selectFields}&$filter=${encodeURIComponent(combinedFilter)}`;
+        this.log.log(`[FetchClient] GET ${url}`);
+        const baseAttributes = await this.fetchAllPages(url);
+        const attributesWithExtras = await Promise.all(
+          baseAttributes.map(async (attr) => {
+            if (attr.AttributeType === "Picklist" || attr.AttributeType === "State" || attr.AttributeType === "Status" || attr.AttributeType === "MultiSelectPicklist") {
+              try {
+                const castType = attr.AttributeType === "State" ? "StateAttributeMetadata" : attr.AttributeType === "Status" ? "StatusAttributeMetadata" : attr.AttributeType === "MultiSelectPicklist" ? "MultiSelectPicklistAttributeMetadata" : "PicklistAttributeMetadata";
+                const optionSetUrl = `${this.baseUrl}/api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')/Attributes(LogicalName='${attr.LogicalName}')/Microsoft.Dynamics.CRM.${castType}?$select=LogicalName&$expand=OptionSet`;
+                const optionResponse = await fetch(optionSetUrl, { method: "GET", headers: this.getHeaders() });
+                if (optionResponse.ok) {
+                  const optionResult = await optionResponse.json();
+                  return { ...attr, OptionSet: optionResult.OptionSet };
+                }
+              } catch (err) {
+                this.log.warn(`[FetchClient] Could not fetch options for ${attr.LogicalName}:`, err);
+              }
+            }
+            if (attr.AttributeType === "Lookup") {
+              try {
+                const lookupUrl = `${this.baseUrl}/api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')/Attributes(LogicalName='${attr.LogicalName}')/Microsoft.Dynamics.CRM.LookupAttributeMetadata?$select=LogicalName,Targets`;
+                const lookupResponse = await fetch(lookupUrl, { method: "GET", headers: this.getHeaders() });
+                if (lookupResponse.ok) {
+                  const lookupResult = await lookupResponse.json();
+                  return { ...attr, Targets: lookupResult.Targets };
+                }
+              } catch (err) {
+                this.log.warn(`[FetchClient] Could not fetch targets for ${attr.LogicalName}:`, err);
+              }
+            }
+            return attr;
+          })
+        );
+        return attributesWithExtras;
+      }
+      async getRelationshipMetadata(entityLogicalName) {
+        const selectFields = [
+          "MetadataId",
+          "SchemaName",
+          "RelationshipType",
+          "ReferencedEntity",
+          "ReferencedAttribute",
+          "ReferencingEntity",
+          "ReferencingAttribute",
+          "IsCustomRelationship",
+          "ReferencingEntityNavigationPropertyName",
+          "ReferencedEntityNavigationPropertyName"
+        ].join(",");
+        const [oneToManyResponse, manyToOneResponse] = await Promise.all([
+          fetch(
+            `${this.baseUrl}/api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')/OneToManyRelationships?$select=${selectFields}`,
+            { method: "GET", headers: this.getHeaders() }
+          ),
+          fetch(
+            `${this.baseUrl}/api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')/ManyToOneRelationships?$select=${selectFields}`,
+            { method: "GET", headers: this.getHeaders() }
+          )
+        ]);
+        const oneToMany = await this.handleResponse(oneToManyResponse);
+        const manyToOne = await this.handleResponse(manyToOneResponse);
+        this.log.log(`[FetchClient] Loaded ${oneToMany.value.length} OneToMany and ${manyToOne.value.length} ManyToOne relationships for ${entityLogicalName}`);
+        return [...oneToMany.value, ...manyToOne.value];
+      }
+      // View Operations
+      async getViews(entityLogicalName) {
+        const selectFields = "savedqueryid,name,fetchxml,layoutxml,isdefault,returnedtypecode,description";
+        const userQuerySelectFields = "userqueryid,name,fetchxml,layoutxml,returnedtypecode,description";
+        const [systemViewsResponse, personalViewsResponse] = await Promise.all([
+          fetch(
+            `${this.baseUrl}/api/data/v9.2/savedqueries?$select=${selectFields}&$filter=returnedtypecode eq '${entityLogicalName}' and querytype eq 0 and statecode eq 0`,
+            { method: "GET", headers: this.getHeaders() }
+          ),
+          fetch(
+            `${this.baseUrl}/api/data/v9.2/userqueries?$select=${userQuerySelectFields}&$filter=returnedtypecode eq '${entityLogicalName}' and statecode eq 0`,
+            { method: "GET", headers: this.getHeaders() }
+          )
+        ]);
+        const systemViews = await this.handleResponse(systemViewsResponse);
+        const personalViews = await this.handleResponse(personalViewsResponse);
+        const views = [
+          ...systemViews.value.map((v) => ({
+            id: v.savedqueryid,
+            name: v.name,
+            fetchxml: v.fetchxml,
+            layoutxml: v.layoutxml,
+            isDefault: v.isdefault || false,
+            isPersonal: false,
+            returnedtypecode: v.returnedtypecode,
+            description: v.description
+          })),
+          ...personalViews.value.map((v) => ({
+            id: v.userqueryid,
+            name: v.name,
+            fetchxml: v.fetchxml,
+            layoutxml: v.layoutxml,
+            isDefault: false,
+            isPersonal: true,
+            returnedtypecode: v.returnedtypecode,
+            description: v.description
+          }))
+        ];
+        views.sort((a, b) => {
+          if (a.isDefault && !b.isDefault) return -1;
+          if (!a.isDefault && b.isDefault) return 1;
+          return a.name.localeCompare(b.name);
+        });
+        return views;
+      }
+      async updateView(isPersonal, viewId, data) {
+        const entitySet = isPersonal ? "userqueries" : "savedqueries";
+        const url = this.buildUrl(entitySet, viewId);
+        this.log.log(`[FetchClient] PATCH ${url}`);
+        const response = await fetch(url, { method: "PATCH", headers: this.getHeaders(), body: JSON.stringify(data) });
+        await this.handleResponse(response);
+      }
+      async createView(entityLogicalName, data) {
+        const url = this.buildUrl("userqueries");
+        const payload = {
+          name: data.name,
+          returnedtypecode: entityLogicalName,
+          fetchxml: data.fetchxml,
+          layoutxml: data.layoutxml,
+          querytype: 0,
+          statecode: 0,
+          ...data.description && { description: data.description }
+        };
+        this.log.log(`[FetchClient] POST ${url}`);
+        const response = await fetch(url, {
+          method: "POST",
+          headers: { ...this.getHeaders(), "Prefer": "return=representation" },
+          body: JSON.stringify(payload)
+        });
+        if (!response.ok) return this.handleResponse(response);
+        const id = this.extractIdFromResponse(response, "userqueries");
+        if (id) return { id };
+        try {
+          const body = await response.json();
+          if (body.userqueryid || body.id) return { id: body.userqueryid || body.id };
+        } catch {
+        }
+        throw new Error("Could not determine created view ID");
+      }
+      async deleteView(isPersonal, viewId) {
+        const entitySet = isPersonal ? "userqueries" : "savedqueries";
+        await this.delete(entitySet, viewId);
+      }
+      async publishEntity(entityLogicalName) {
+        const url = `${this.baseUrl}/api/data/v9.2/PublishXml`;
+        const parameterXml = `<importexportxml><entities><entity>${entityLogicalName}</entity></entities></importexportxml>`;
+        this.log.log(`[FetchClient] POST ${url} - Publishing ${entityLogicalName}`);
+        const response = await fetch(url, {
+          method: "POST",
+          headers: this.getHeaders(),
+          body: JSON.stringify({ ParameterXml: parameterXml })
+        });
+        await this.handleResponse(response);
+      }
+      // Global Option Set Operations
+      async getGlobalOptionSets() {
+        const url = `${this.baseUrl}/api/data/v9.2/GlobalOptionSetDefinitions`;
+        this.log.log(`[FetchClient] GET ${url}`);
+        const all = await this.fetchAllPages(url);
+        return all.filter((os) => os.OptionSetType === "Picklist" && os.IsGlobal);
+      }
+    };
+    var XrmClient = class {
+      constructor(xrm, logger) {
+        this.xrm = xrm;
+        this.log = logger ?? console;
+      }
+      getClientUrl() {
+        return this.xrm.Utility.getGlobalContext().getClientUrl();
+      }
+      // CRUD Operations
+      async retrieve(entitySetName, id, options) {
+        const cleanId = id.replace(/[{}]/g, "");
+        const result = await this.xrm.WebApi.retrieveRecord(entitySetName, cleanId, options);
+        return result;
+      }
+      async retrieveMultiple(entitySetName, options) {
+        const result = await this.xrm.WebApi.retrieveMultipleRecords(entitySetName, options);
+        return { value: result.entities };
+      }
+      async create(entitySetName, data) {
+        const result = await this.xrm.WebApi.createRecord(entitySetName, data);
+        return { id: result.id };
+      }
+      async update(entitySetName, id, data) {
+        await this.xrm.WebApi.updateRecord(entitySetName, id.replace(/[{}]/g, ""), data);
+      }
+      async delete(entitySetName, id) {
+        await this.xrm.WebApi.deleteRecord(entitySetName, id.replace(/[{}]/g, ""));
+      }
+      // Batch Operations
+      async batchDelete(entitySetName, ids) {
+        const succeeded = [];
+        const failed = [];
+        for (const id of ids) {
+          try {
+            await this.delete(entitySetName, id);
+            succeeded.push(id);
+          } catch (err) {
+            failed.push({ id, error: err instanceof Error ? err.message : "Delete failed" });
+          }
+        }
+        return { succeeded, failed };
+      }
+      async batchUpdate(entitySetName, records) {
+        const succeeded = [];
+        const failed = [];
+        for (const record of records) {
+          try {
+            await this.update(entitySetName, record.id, record.data);
+            succeeded.push(record.id);
+          } catch (err) {
+            failed.push({ id: record.id, error: err instanceof Error ? err.message : "Update failed" });
+          }
+        }
+        return { succeeded, failed };
+      }
+      async batchCreate(entitySetName, records) {
+        const succeeded = [];
+        const failed = [];
+        for (let i = 0; i < records.length; i++) {
+          try {
+            const result = await this.create(entitySetName, records[i]);
+            succeeded.push({ id: result.id, data: records[i] });
+          } catch (err) {
+            failed.push({ rowNumber: i + 1, error: err instanceof Error ? err.message : "Create failed" });
+          }
+        }
+        return { succeeded, failed };
+      }
+      // Metadata Operations
+      async getEntityDefinitions(filter) {
+        const selectFields = [
+          "LogicalName",
+          "EntitySetName",
+          "SchemaName",
+          "DisplayName",
+          "DisplayCollectionName",
+          "PrimaryIdAttribute",
+          "PrimaryNameAttribute",
+          "IsCustomEntity",
+          "IsActivity",
+          "IsValidForAdvancedFind",
+          "ObjectTypeCode"
+        ].join(",");
+        let options = `?$select=${selectFields}`;
+        if (filter) options += `&$filter=${filter}`;
+        const result = await this.xrm.WebApi.retrieveMultipleRecords("EntityDefinitions", options);
+        return result.entities;
+      }
+      async getAttributeMetadata(entityLogicalName, filter) {
+        const selectFields = [
+          "LogicalName",
+          "SchemaName",
+          "DisplayName",
+          "Description",
+          "AttributeType",
+          "AttributeTypeName",
+          "RequiredLevel",
+          "IsValidForRead",
+          "IsValidForCreate",
+          "IsValidForUpdate",
+          "IsPrimaryId",
+          "IsPrimaryName"
+        ].join(",");
+        const defaultFilter = "IsValidForRead eq true";
+        const combinedFilter = filter ? `${defaultFilter} and ${filter}` : defaultFilter;
+        const clientUrl = this.getClientUrl();
+        const url = `${clientUrl}/api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')/Attributes?$select=${selectFields}&$filter=${combinedFilter}`;
+        const response = await fetch(url, {
+          method: "GET",
+          headers: { "Accept": "application/json", "OData-MaxVersion": "4.0", "OData-Version": "4.0" }
+        });
+        if (!response.ok) throw new Error(`Failed to fetch attribute metadata: ${response.statusText}`);
+        const result = await response.json();
+        const attributes = result.value;
+        const attributesWithExtras = await Promise.all(
+          attributes.map(async (attr) => {
+            if (attr.AttributeType === "Picklist" || attr.AttributeType === "State" || attr.AttributeType === "Status") {
+              try {
+                const castType = attr.AttributeType === "State" ? "StateAttributeMetadata" : attr.AttributeType === "Status" ? "StatusAttributeMetadata" : "PicklistAttributeMetadata";
+                const optionSetUrl = `${clientUrl}/api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')/Attributes(LogicalName='${attr.LogicalName}')/Microsoft.Dynamics.CRM.${castType}?$select=LogicalName&$expand=OptionSet`;
+                const optionResponse = await fetch(optionSetUrl, {
+                  method: "GET",
+                  headers: { "Accept": "application/json", "OData-MaxVersion": "4.0", "OData-Version": "4.0" }
+                });
+                if (optionResponse.ok) {
+                  const optionResult = await optionResponse.json();
+                  return { ...attr, OptionSet: optionResult.OptionSet };
+                }
+              } catch (err) {
+                this.log.warn(`Could not fetch options for ${attr.LogicalName}:`, err);
+              }
+            }
+            if (attr.AttributeType === "Lookup") {
+              try {
+                const lookupUrl = `${clientUrl}/api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')/Attributes(LogicalName='${attr.LogicalName}')/Microsoft.Dynamics.CRM.LookupAttributeMetadata?$select=LogicalName,Targets`;
+                const lookupResponse = await fetch(lookupUrl, {
+                  method: "GET",
+                  headers: { "Accept": "application/json", "OData-MaxVersion": "4.0", "OData-Version": "4.0" }
+                });
+                if (lookupResponse.ok) {
+                  const lookupResult = await lookupResponse.json();
+                  return { ...attr, Targets: lookupResult.Targets };
+                }
+              } catch (err) {
+                this.log.warn(`Could not fetch targets for ${attr.LogicalName}:`, err);
+              }
+            }
+            return attr;
+          })
+        );
+        return attributesWithExtras;
+      }
+      async getRelationshipMetadata(entityLogicalName) {
+        const clientUrl = this.getClientUrl();
+        const selectFields = [
+          "MetadataId",
+          "SchemaName",
+          "RelationshipType",
+          "ReferencedEntity",
+          "ReferencedAttribute",
+          "ReferencingEntity",
+          "ReferencingAttribute",
+          "IsCustomRelationship",
+          "ReferencingEntityNavigationPropertyName",
+          "ReferencedEntityNavigationPropertyName"
+        ].join(",");
+        const [oneToManyResponse, manyToOneResponse] = await Promise.all([
+          fetch(
+            `${clientUrl}/api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')/OneToManyRelationships?$select=${selectFields}`,
+            { method: "GET", headers: { "Accept": "application/json", "OData-MaxVersion": "4.0", "OData-Version": "4.0" } }
+          ),
+          fetch(
+            `${clientUrl}/api/data/v9.2/EntityDefinitions(LogicalName='${entityLogicalName}')/ManyToOneRelationships?$select=${selectFields}`,
+            { method: "GET", headers: { "Accept": "application/json", "OData-MaxVersion": "4.0", "OData-Version": "4.0" } }
+          )
+        ]);
+        if (!oneToManyResponse.ok) throw new Error(`Failed to fetch OneToMany relationships: ${oneToManyResponse.statusText}`);
+        if (!manyToOneResponse.ok) throw new Error(`Failed to fetch ManyToOne relationships: ${manyToOneResponse.statusText}`);
+        const oneToMany = await oneToManyResponse.json();
+        const manyToOne = await manyToOneResponse.json();
+        this.log.log(`[XrmClient] Loaded ${oneToMany.value.length} OneToMany and ${manyToOne.value.length} ManyToOne relationships for ${entityLogicalName}`);
+        return [...oneToMany.value, ...manyToOne.value];
+      }
+      // View Operations
+      async getViews(entityLogicalName) {
+        const clientUrl = this.getClientUrl();
+        const selectFields = "savedqueryid,name,fetchxml,layoutxml,isdefault,returnedtypecode,description";
+        const userQuerySelectFields = "userqueryid,name,fetchxml,layoutxml,returnedtypecode,description";
+        const [systemViewsResponse, personalViewsResponse] = await Promise.all([
+          fetch(
+            `${clientUrl}/api/data/v9.2/savedqueries?$select=${selectFields}&$filter=returnedtypecode eq '${entityLogicalName}' and querytype eq 0 and statecode eq 0`,
+            { method: "GET", headers: { "Accept": "application/json", "OData-MaxVersion": "4.0", "OData-Version": "4.0" } }
+          ),
+          fetch(
+            `${clientUrl}/api/data/v9.2/userqueries?$select=${userQuerySelectFields}&$filter=returnedtypecode eq '${entityLogicalName}' and statecode eq 0`,
+            { method: "GET", headers: { "Accept": "application/json", "OData-MaxVersion": "4.0", "OData-Version": "4.0" } }
+          )
+        ]);
+        if (!systemViewsResponse.ok) throw new Error(`Failed to fetch system views: ${systemViewsResponse.statusText}`);
+        if (!personalViewsResponse.ok) throw new Error(`Failed to fetch personal views: ${personalViewsResponse.statusText}`);
+        const systemViews = await systemViewsResponse.json();
+        const personalViews = await personalViewsResponse.json();
+        const views = [
+          ...systemViews.value.map((v) => ({
+            id: v.savedqueryid,
+            name: v.name,
+            fetchxml: v.fetchxml,
+            layoutxml: v.layoutxml,
+            isDefault: v.isdefault || false,
+            isPersonal: false,
+            returnedtypecode: v.returnedtypecode,
+            description: v.description
+          })),
+          ...personalViews.value.map((v) => ({
+            id: v.userqueryid,
+            name: v.name,
+            fetchxml: v.fetchxml,
+            layoutxml: v.layoutxml,
+            isDefault: false,
+            isPersonal: true,
+            returnedtypecode: v.returnedtypecode,
+            description: v.description
+          }))
+        ];
+        views.sort((a, b) => {
+          if (a.isDefault && !b.isDefault) return -1;
+          if (!a.isDefault && b.isDefault) return 1;
+          return a.name.localeCompare(b.name);
+        });
+        return views;
+      }
+      async updateView(isPersonal, viewId, data) {
+        const entityName = isPersonal ? "userquery" : "savedquery";
+        await this.xrm.WebApi.updateRecord(entityName, viewId.replace(/[{}]/g, ""), data);
+      }
+      async createView(entityLogicalName, data) {
+        const payload = {
+          name: data.name,
+          returnedtypecode: entityLogicalName,
+          fetchxml: data.fetchxml,
+          layoutxml: data.layoutxml,
+          querytype: 0,
+          statecode: 0,
+          ...data.description && { description: data.description }
+        };
+        const result = await this.xrm.WebApi.createRecord("userquery", payload);
+        return { id: result.id };
+      }
+      async deleteView(isPersonal, viewId) {
+        const entityName = isPersonal ? "userquery" : "savedquery";
+        await this.xrm.WebApi.deleteRecord(entityName, viewId.replace(/[{}]/g, ""));
+      }
+      async publishEntity(entityLogicalName) {
+        const clientUrl = this.getClientUrl();
+        const url = `${clientUrl}/api/data/v9.2/PublishXml`;
+        const parameterXml = `<importexportxml><entities><entity>${entityLogicalName}</entity></entities></importexportxml>`;
+        const response = await fetch(url, {
+          method: "POST",
+          headers: { "Accept": "application/json", "Content-Type": "application/json; charset=utf-8", "OData-MaxVersion": "4.0", "OData-Version": "4.0" },
+          body: JSON.stringify({ ParameterXml: parameterXml })
+        });
+        if (!response.ok) throw new Error(`Failed to publish entity: ${response.statusText}`);
+      }
+      // Global Option Set Operations
+      async getGlobalOptionSets() {
+        const clientUrl = this.getClientUrl();
+        const url = `${clientUrl}/api/data/v9.2/GlobalOptionSetDefinitions`;
+        const response = await fetch(url, {
+          method: "GET",
+          headers: { "Accept": "application/json", "OData-MaxVersion": "4.0", "OData-Version": "4.0" }
+        });
+        if (!response.ok) throw new Error(`Failed to fetch global option sets: ${response.statusText}`);
+        const result = await response.json();
+        return result.value.filter((os) => os.OptionSetType === "Picklist" && os.IsGlobal);
+      }
+    };
+    function generateId() {
+      return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 | 0;
+        const v = c === "x" ? r : r & 3 | 8;
+        return v.toString(16);
+      });
+    }
+    var MockClient = class {
+      constructor(config, logger) {
+        this.dataStore = config?.records ?? {};
+        this.entityDefs = config?.entityDefinitions ?? [];
+        this.attrMeta = config?.attributeMetadata ?? {};
+        this.viewStore = config?.views ?? {};
+        this.relMeta = config?.relationshipMetadata ?? {};
+        this.globalOptionSets = config?.globalOptionSets ?? [];
+        this.delayMs = config?.delayMs ?? 0;
+        this.log = logger ?? console;
+      }
+      async delay() {
+        if (this.delayMs > 0) {
+          return new Promise((resolve) => setTimeout(resolve, this.delayMs));
+        }
+      }
+      // CRUD Operations
+      async retrieve(entitySetName, id) {
+        await this.delay();
+        const records = this.dataStore[entitySetName] ?? [];
+        const pkField = entitySetName.slice(0, -1) + "id";
+        const record = records.find((r) => r[pkField] === id || r.id === id);
+        if (!record) throw new Error(`Record ${id} not found in ${entitySetName}`);
+        return record;
+      }
+      async retrieveMultiple(entitySetName) {
+        await this.delay();
+        return { value: this.dataStore[entitySetName] ?? [] };
+      }
+      async create(entitySetName, data) {
+        await this.delay();
+        const id = generateId();
+        const pkField = entitySetName.slice(0, -1) + "id";
+        const record = { ...data, [pkField]: id };
+        if (!this.dataStore[entitySetName]) this.dataStore[entitySetName] = [];
+        this.dataStore[entitySetName].push(record);
+        return { id };
+      }
+      async update(entitySetName, id, data) {
+        await this.delay();
+        const records = this.dataStore[entitySetName] ?? [];
+        const pkField = entitySetName.slice(0, -1) + "id";
+        const index = records.findIndex((r) => r[pkField] === id || r.id === id);
+        if (index === -1) throw new Error(`Record ${id} not found in ${entitySetName}`);
+        this.dataStore[entitySetName][index] = { ...records[index], ...data };
+      }
+      async delete(entitySetName, id) {
+        await this.delay();
+        const records = this.dataStore[entitySetName] ?? [];
+        const pkField = entitySetName.slice(0, -1) + "id";
+        const index = records.findIndex((r) => r[pkField] === id || r.id === id);
+        if (index === -1) throw new Error(`Record ${id} not found in ${entitySetName}`);
+        this.dataStore[entitySetName].splice(index, 1);
+      }
+      // Batch Operations
+      async batchDelete(entitySetName, ids) {
+        const succeeded = [];
+        const failed = [];
+        for (const id of ids) {
+          try {
+            await this.delete(entitySetName, id);
+            succeeded.push(id);
+          } catch (err) {
+            failed.push({ id, error: err instanceof Error ? err.message : "Delete failed" });
+          }
+        }
+        return { succeeded, failed };
+      }
+      async batchUpdate(entitySetName, records) {
+        const succeeded = [];
+        const failed = [];
+        for (const record of records) {
+          try {
+            await this.update(entitySetName, record.id, record.data);
+            succeeded.push(record.id);
+          } catch (err) {
+            failed.push({ id: record.id, error: err instanceof Error ? err.message : "Update failed" });
+          }
+        }
+        return { succeeded, failed };
+      }
+      async batchCreate(entitySetName, records) {
+        const succeeded = [];
+        const failed = [];
+        for (let i = 0; i < records.length; i++) {
+          try {
+            const result = await this.create(entitySetName, records[i]);
+            succeeded.push({ id: result.id, data: records[i] });
+          } catch (err) {
+            failed.push({ rowNumber: i + 1, error: err instanceof Error ? err.message : "Create failed" });
+          }
+        }
+        return { succeeded, failed };
+      }
+      // Metadata Operations
+      async getEntityDefinitions(_filter) {
+        await this.delay();
+        return this.entityDefs;
+      }
+      async getAttributeMetadata(entityLogicalName) {
+        await this.delay();
+        return this.attrMeta[entityLogicalName] ?? [];
+      }
+      async getRelationshipMetadata(entityLogicalName) {
+        await this.delay();
+        return this.relMeta[entityLogicalName] ?? [];
+      }
+      // View Operations
+      async getViews(entityLogicalName) {
+        await this.delay();
+        return this.viewStore[entityLogicalName] ?? [];
+      }
+      async updateView(_isPersonal, viewId, data) {
+        await this.delay();
+        for (const entity of Object.keys(this.viewStore)) {
+          const views = this.viewStore[entity];
+          const idx = views.findIndex((v) => v.id === viewId);
+          if (idx !== -1) {
+            this.viewStore[entity][idx] = { ...views[idx], ...data };
+            return;
+          }
+        }
+        throw new Error(`View ${viewId} not found`);
+      }
+      async createView(entityLogicalName, data) {
+        await this.delay();
+        const id = generateId();
+        const view = {
+          id,
+          name: data.name,
+          fetchxml: data.fetchxml,
+          layoutxml: data.layoutxml,
+          isDefault: false,
+          isPersonal: true,
+          returnedtypecode: entityLogicalName,
+          description: data.description
+        };
+        if (!this.viewStore[entityLogicalName]) this.viewStore[entityLogicalName] = [];
+        this.viewStore[entityLogicalName].push(view);
+        return { id };
+      }
+      async deleteView(_isPersonal, viewId) {
+        await this.delay();
+        for (const entity of Object.keys(this.viewStore)) {
+          const views = this.viewStore[entity];
+          const idx = views.findIndex((v) => v.id === viewId);
+          if (idx !== -1) {
+            this.viewStore[entity].splice(idx, 1);
+            return;
+          }
+        }
+        throw new Error(`View ${viewId} not found`);
+      }
+      async publishEntity() {
+        await this.delay();
+        this.log.log("[MockClient] publishEntity called (no-op in mock mode)");
+      }
+      // Global Option Set Operations
+      async getGlobalOptionSets() {
+        await this.delay();
+        return this.globalOptionSets;
+      }
+    };
+    function createClient2(options) {
+      const logger = options?.logger;
+      if (options?.baseUrl && options?.token) {
+        return new FetchClient(options.baseUrl, options.token, logger);
+      }
+      if (options?.xrm) {
+        return new XrmClient(options.xrm, logger);
+      }
+      if (typeof window !== "undefined") {
+        const win = window;
+        if (win.__DYNAMICS_URL && win.__DYNAMICS_TOKEN) {
+          return new FetchClient(win.__DYNAMICS_URL, win.__DYNAMICS_TOKEN, logger);
+        }
+      }
+      if (typeof globalThis !== "undefined" && typeof globalThis.Xrm !== "undefined") {
+        return new XrmClient(globalThis.Xrm, logger);
+      }
+      return new MockClient(options?.mockData, logger);
+    }
+    function getEnvironmentInfo() {
+      const hostname = typeof window !== "undefined" ? window.location?.hostname ?? "unknown" : "node";
+      const hasXrm = typeof globalThis !== "undefined" && typeof globalThis.Xrm !== "undefined";
+      const win = typeof window !== "undefined" ? window : {};
+      const hasToken = !!(win.__DYNAMICS_URL && win.__DYNAMICS_TOKEN);
+      let type = "mock";
+      if (hasToken) type = "fetch";
+      else if (hasXrm) type = "xrm";
+      return { type, hostname, baseUrl: win.__DYNAMICS_URL, hasToken, hasXrm };
+    }
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+
+// src/metadata/adapter.ts
+init_esm_shims();
+function toAttributeMetadataInput(attr) {
+  return {
+    LogicalName: attr.LogicalName,
+    SchemaName: attr.SchemaName,
+    DisplayName: attr.DisplayName,
+    AttributeType: attr.AttributeType,
+    RequiredLevel: attr.RequiredLevel,
+    IsValidForRead: attr.IsValidForRead,
+    IsValidForCreate: attr.IsValidForCreate,
+    IsValidForUpdate: attr.IsValidForUpdate,
+    IsPrimaryId: attr.IsPrimaryId,
+    IsPrimaryName: attr.IsPrimaryName,
+    MaxLength: attr.MaxLength,
+    Precision: attr.Precision,
+    MinValue: attr.MinValue,
+    MaxValue: attr.MaxValue,
+    Format: attr.Format,
+    FormatName: attr.FormatName,
+    OptionSet: attr.OptionSet,
+    GlobalOptionSet: attr.GlobalOptionSet,
+    DateTimeBehavior: attr.DateTimeBehavior,
+    Targets: attr.Targets
+  };
+}
+function toEntityMetadataInput(entity, attributes) {
+  if (!entity?.LogicalName) {
+    throw new Error("toEntityMetadataInput: entity.LogicalName is required.");
+  }
+  if (!entity.EntitySetName) {
+    throw new Error(`toEntityMetadataInput: ${entity.LogicalName} is missing EntitySetName.`);
+  }
+  if (!entity.PrimaryIdAttribute) {
+    throw new Error(`toEntityMetadataInput: ${entity.LogicalName} is missing PrimaryIdAttribute.`);
+  }
+  const primaryName = entity.PrimaryNameAttribute || entity.PrimaryIdAttribute;
+  return {
+    LogicalName: entity.LogicalName,
+    EntitySetName: entity.EntitySetName,
+    SchemaName: entity.SchemaName,
+    DisplayName: entity.DisplayName,
+    DisplayCollectionName: entity.DisplayCollectionName,
+    PrimaryIdAttribute: entity.PrimaryIdAttribute,
+    PrimaryNameAttribute: primaryName,
+    IsCustomEntity: entity.IsCustomEntity,
+    Attributes: attributes.map(toAttributeMetadataInput)
+  };
+}
+
+// src/metadata/fetch.ts
+init_esm_shims();
+
+// src/metadata/typedCast.ts
+init_esm_shims();
+
+// src/metadata/http.ts
+init_esm_shims();
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function buildUrl(http, relativePath) {
+  const version = http.apiVersion ?? "9.2";
+  const base = http.baseUrl.replace(/\/+$/, "");
+  return `${base}/api/data/v${version}/${relativePath}`;
+}
+async function getWithRetry(http, url, maxRetries) {
+  for (let attempt = 0; ; attempt += 1) {
+    const res = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${http.token}`,
+        Accept: "application/json",
+        "OData-MaxVersion": "4.0",
+        "OData-Version": "4.0"
+      }
+    });
+    if (res.status === 429 || res.status === 503) {
+      if (attempt >= maxRetries) {
+        throw new Error(`Dataverse throttled (${res.status}) after ${attempt} retries: ${url}`);
+      }
+      const headerWait = Number(res.headers.get("Retry-After"));
+      const waitSec = Number.isFinite(headerWait) && headerWait > 0 ? headerWait : Math.min(2 ** attempt, 30);
+      await sleep(waitSec * 1e3);
+      continue;
+    }
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(
+        `Dataverse metadata GET ${res.status} ${res.statusText}: ${url}
+${body.slice(0, 300)}`
+      );
+    }
+    return await res.json();
+  }
+}
+async function metadataGet(http, relativePath, maxRetries = 4) {
+  return getWithRetry(http, buildUrl(http, relativePath), maxRetries);
+}
+async function metadataGetAll(http, relativePath, maxRetries = 4) {
+  const out = [];
+  let url = buildUrl(http, relativePath);
+  while (url) {
+    const page = await getWithRetry(http, url, maxRetries);
+    if (page.value) out.push(...page.value);
+    url = page["@odata.nextLink"];
+  }
+  return out;
+}
+
+// src/metadata/typedCast.ts
+var SPECS = [
+  { types: ["String"], cast: "StringAttributeMetadata", select: ["MaxLength", "Format"] },
+  { types: ["Memo"], cast: "MemoAttributeMetadata", select: ["MaxLength", "Format"] },
+  { types: ["Integer"], cast: "IntegerAttributeMetadata", select: ["MinValue", "MaxValue", "Format"] },
+  { types: ["BigInt"], cast: "BigIntAttributeMetadata", select: ["MinValue", "MaxValue"] },
+  { types: ["Decimal"], cast: "DecimalAttributeMetadata", select: ["MinValue", "MaxValue", "Precision"] },
+  { types: ["Double"], cast: "DoubleAttributeMetadata", select: ["MinValue", "MaxValue", "Precision"] },
+  { types: ["Money"], cast: "MoneyAttributeMetadata", select: ["MinValue", "MaxValue", "Precision"] },
+  { types: ["DateTime"], cast: "DateTimeAttributeMetadata", select: ["Format", "DateTimeBehavior"] }
+];
+function mergeScalarDetail(attrs, details) {
+  const byName = new Map(details.map((d) => [d.LogicalName, d]));
+  for (const a of attrs) {
+    const d = byName.get(a.LogicalName);
+    if (!d) continue;
+    if (d.MaxLength != null && a.MaxLength == null) a.MaxLength = d.MaxLength;
+    if (d.MinValue != null && a.MinValue == null) a.MinValue = d.MinValue;
+    if (d.MaxValue != null && a.MaxValue == null) a.MaxValue = d.MaxValue;
+    if (d.Precision != null && a.Precision == null) a.Precision = d.Precision;
+    if (d.Format != null && a.Format == null) a.Format = d.Format;
+    if (d.DateTimeBehavior != null && a.DateTimeBehavior == null) a.DateTimeBehavior = d.DateTimeBehavior;
+  }
+}
+async function augmentScalarDetail(http, logicalName, attrs, get = async (h, p) => ({ value: await metadataGetAll(h, p) })) {
+  const presentTypes = new Set(attrs.map((a) => a.AttributeType));
+  for (const spec of SPECS) {
+    if (!spec.types.some((t) => presentTypes.has(t))) continue;
+    const select = ["LogicalName", ...spec.select].join(",");
+    const path2 = `EntityDefinitions(LogicalName='${logicalName}')/Attributes/Microsoft.Dynamics.CRM.${spec.cast}?$select=${select}`;
+    try {
+      const resp = await get(http, path2);
+      mergeScalarDetail(attrs, resp.value ?? []);
+    } catch {
+    }
+  }
+}
+
+// src/validate.ts
+init_esm_shims();
+var LOGICAL_NAME_PATTERN = /^[a-z][a-z0-9_]*$/;
+function assertValidEntityName(name) {
+  if (!name || !LOGICAL_NAME_PATTERN.test(name)) {
+    throw new Error(
+      `Invalid entity logical name ${JSON.stringify(name)} \u2014 expected a lowercase letter followed by [a-z0-9_] (Dataverse logical-name rule).`
+    );
+  }
+  return name;
+}
+
+// src/metadata/fetch.ts
+async function fetchEntityMetadata(client, logicalName, options = {}) {
+  assertValidEntityName(logicalName);
+  const defs = await client.getEntityDefinitions(`LogicalName eq '${logicalName}'`);
+  const entity = defs[0];
+  if (!entity) {
+    throw new Error(
+      `Entity '${logicalName}' was not found in this org (no EntityDefinitions match). Check the logical name (singular, lowercase) and that your token targets the right org.`
+    );
+  }
+  const attributes = await client.getAttributeMetadata(logicalName, options.attributeFilter);
+  const input = toEntityMetadataInput(entity, attributes);
+  if (options.augment) {
+    try {
+      await augmentScalarDetail(options.augment, logicalName, input.Attributes);
+    } catch (e) {
+      console.warn(
+        `[dvgen] scalar detail augmentation skipped for ${logicalName}: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+  }
+  return input;
+}
+
+// src/io/write.ts
+init_esm_shims();
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "fs";
+import { dirname } from "path";
+function safeWrite(path2, content, opts = {}) {
+  const exists = existsSync(path2);
+  const current = exists ? readFileSync(path2, "utf8") : void 0;
+  if (exists && current === content) return "unchanged";
+  if (opts.diff && exists) printDiff(path2, current ?? "", content);
+  if (opts.dryRun) return "dry-run";
+  if (exists && !opts.force) {
+    return "skipped-exists";
+  }
+  mkdirSync(dirname(path2), { recursive: true });
+  writeFileSync(path2, content, "utf8");
+  return exists ? "overwritten" : "created";
+}
+function printDiff(path2, before, after) {
+  const a = before.split("\n");
+  const b = after.split("\n");
+  console.log(`
+--- ${path2} (existing)
++++ ${path2} (generated)`);
+  const max = Math.max(a.length, b.length);
+  for (let i = 0; i < max; i += 1) {
+    if (a[i] === b[i]) continue;
+    if (a[i] !== void 0) console.log(`- ${a[i]}`);
+    if (b[i] !== void 0) console.log(`+ ${b[i]}`);
+  }
+}
+
+// src/connection.ts
+init_esm_shims();
+var import_api_client = __toESM(require_dist(), 1);
+
+// ../dev-tools/dist/index.mjs
+init_esm_shims();
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { execFileSync } from "child_process";
+var URL_ENV_KEYS = [
+  "VITE_DYNAMICS_URL",
+  "REACT_APP_DYNAMICS_URL",
+  "DYNAMICS_URL"
+];
+function parseEnvFile(content) {
+  const result = {};
+  if (content.charCodeAt(0) === 65279) {
+    content = content.slice(1);
+  }
+  const lines = content.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    let value = trimmed.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function loadEnv(options = {}) {
+  let values = {};
+  if (options.path) {
+    if (!existsSync2(options.path)) {
+      throw new Error(`Env file not found: ${options.path}`);
+    }
+    const content = readFileSync2(options.path, "utf-8");
+    values = parseEnvFile(content);
+  }
+  const fallback = options.fallbackToProcessEnv ?? !options.path;
+  const lookup = (key) => {
+    if (key in values && values[key] !== "") return values[key];
+    if (fallback) {
+      const v = process.env[key];
+      if (v !== void 0 && v !== "") return v;
+    }
+    return void 0;
+  };
+  for (const key of URL_ENV_KEYS) {
+    const v = lookup(key);
+    if (v !== void 0) {
+      return { url: v, matchedKey: key, values };
+    }
+  }
+  return { url: void 0, matchedKey: void 0, values };
+}
+var AzCliError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "AzCliError";
+    if (cause !== void 0) this.cause = cause;
+  }
+};
+function getToken(options) {
+  const { resource } = options;
+  if (!resource) {
+    throw new Error("getToken: resource is required (Dataverse URL)");
+  }
+  const az = options.azCommand ?? "az";
+  const args = [
+    "account",
+    "get-access-token",
+    "--resource",
+    resource,
+    "--output",
+    "json"
+  ];
+  let stdout;
+  try {
+    if (options.exec) {
+      stdout = options.exec(az, args);
+    } else {
+      stdout = execFileSync(az, args, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    }
+  } catch (err) {
+    const errObj = err;
+    const stderr = typeof errObj.stderr === "string" ? errObj.stderr : errObj.stderr?.toString("utf-8") ?? errObj.message ?? "";
+    if (errObj.code === "ENOENT") {
+      throw new AzCliError(
+        "Azure CLI (`az`) is not installed or not on PATH. Install: https://learn.microsoft.com/cli/azure/install-azure-cli",
+        err
+      );
+    }
+    if (/please run.*az login/i.test(stderr) || /not logged in/i.test(stderr)) {
+      throw new AzCliError(
+        "Azure CLI is not authenticated. Run `az login` and retry.",
+        err
+      );
+    }
+    throw new AzCliError(
+      `Failed to acquire token via Azure CLI: ${stderr.trim() || "unknown error"}`,
+      err
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch (err) {
+    throw new AzCliError(`Could not parse Azure CLI JSON output: ${stdout}`, err);
+  }
+  if (!parsed.accessToken) {
+    throw new AzCliError(`Azure CLI returned no accessToken: ${stdout}`);
+  }
+  const expiresOn = new Date(parsed.expiresOn);
+  if (Number.isNaN(expiresOn.getTime())) {
+    throw new AzCliError(`Azure CLI returned unparseable expiresOn: ${parsed.expiresOn}`);
+  }
+  return { token: parsed.accessToken, expiresOn };
+}
+
+// src/connection.ts
+function resolveConnection(opts) {
+  const env = loadEnv({ path: opts.envFile, fallbackToProcessEnv: true });
+  const url = opts.url ?? env.url;
+  if (!url) {
+    throw new Error(
+      "No Dataverse URL found. Pass --url <url>, or set one of VITE_DYNAMICS_URL / REACT_APP_DYNAMICS_URL / DYNAMICS_URL (optionally via --env-file)."
+    );
+  }
+  let token = opts.token;
+  let tokenSource = "flag";
+  if (!token) {
+    token = env.values.DYNAMICS_TOKEN ?? env.values.VITE_DYNAMICS_TOKEN ?? env.values.REACT_APP_DYNAMICS_TOKEN ?? process.env.DYNAMICS_TOKEN ?? process.env.VITE_DYNAMICS_TOKEN ?? process.env.REACT_APP_DYNAMICS_TOKEN;
+    if (token) tokenSource = "env";
+  }
+  if (!token) {
+    token = getToken({ resource: url }).token;
+    tokenSource = "azure-cli";
+  }
+  const client = (0, import_api_client.createClient)({ baseUrl: url, token });
+  return { client, url, token, tokenSource };
+}
+
+// src/metadata/links.ts
+init_esm_shims();
+async function deriveParentLookupLinks(client, entity) {
+  try {
+    const lookupAttrs = new Set(
+      entity.Attributes.filter(
+        (a) => ["Lookup", "Customer", "Owner"].includes(a.AttributeType)
+      ).map((a) => a.LogicalName)
+    );
+    const rels = await client.getRelationshipMetadata(entity.LogicalName);
+    const seenAliases = /* @__PURE__ */ new Set();
+    return rels.filter(
+      (r) => r.ReferencingEntity === entity.LogicalName && lookupAttrs.has(r.ReferencingAttribute)
+    ).map((r) => {
+      let alias = r.ReferencingEntityNavigationPropertyName || r.ReferencedEntity;
+      let n = 2;
+      while (seenAliases.has(alias)) alias = `${r.ReferencedEntity}${n++}`;
+      seenAliases.add(alias);
+      return {
+        entity: r.ReferencedEntity,
+        from: r.ReferencedAttribute,
+        to: r.ReferencingAttribute,
+        alias
+      };
+    });
+  } catch (e) {
+    console.warn(
+      `  \u26A0 could not fetch relationships for ${entity.LogicalName}: ${e instanceof Error ? e.message : String(e)} (emitting TODO scaffold)`
+    );
+    return [];
+  }
+}
+
+// src/design/parse.ts
+init_esm_shims();
+var FORM_DESIGN_KIND = "dynamics-ui-kit.form-design";
+function parseDesignFile(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`Design file is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("Design file must be a JSON object.");
+  }
+  const file = parsed;
+  if (file.kind && file.kind !== FORM_DESIGN_KIND) {
+    throw new Error(
+      `Unexpected design kind ${JSON.stringify(file.kind)} (expected ${JSON.stringify(FORM_DESIGN_KIND)}). Is this a *.design.json exported from the form designer?`
+    );
+  }
+  if (!Array.isArray(file.forms)) {
+    throw new Error("Design file has no `forms` array \u2014 nothing to scan.");
+  }
+  return file;
+}
+function collectEntities(design) {
+  const found = /* @__PURE__ */ new Map();
+  const skipped = [];
+  const add = (raw, source) => {
+    if (typeof raw !== "string") return;
+    const name = raw.trim().toLowerCase();
+    if (!name) return;
+    try {
+      assertValidEntityName(name);
+    } catch {
+      if (!skipped.some((s) => s.name === name)) {
+        skipped.push({ name, reason: "not a valid Dataverse logical name" });
+      }
+      return;
+    }
+    if (!found.has(name)) found.set(name, /* @__PURE__ */ new Set());
+    found.get(name).add(source);
+  };
+  const walkSections = (sections, formName) => {
+    for (const section of sections ?? []) {
+      for (const row of section.rows ?? []) {
+        for (const cell of row.cells ?? []) {
+          const c = cell?.control;
+          if (!c) continue;
+          if (c.type === "subgrid") {
+            add(c.properties?.entityName, `subgrid in "${formName}"`);
+          }
+          if (c.type === "lookup" && Array.isArray(c.dataBinding?.lookupTargets)) {
+            for (const t of c.dataBinding.lookupTargets) {
+              add(t, `lookup in "${formName}"`);
+            }
+          }
+        }
+      }
+    }
+  };
+  for (const form of design.forms ?? []) {
+    const formName = form.name ?? "(unnamed form)";
+    add(form.settings?.dataSources?.[0]?.entityName, `form "${formName}" (target)`);
+    walkSections(form.sections, formName);
+    for (const tab of form.tabs ?? []) walkSections(tab.sections, formName);
+  }
+  const entities = [...found.entries()].map(([logicalName, sources]) => ({ logicalName, sources: [...sources] })).sort((a, b) => a.logicalName.localeCompare(b.logicalName));
+  return { entities, skipped };
+}
+export {
+  FORM_DESIGN_KIND,
+  augmentScalarDetail,
+  collectEntities,
+  deriveParentLookupLinks,
+  fetchEntityMetadata,
+  mergeScalarDetail,
+  metadataGet,
+  metadataGetAll,
+  parseDesignFile,
+  resolveConnection,
+  safeWrite,
+  toAttributeMetadataInput,
+  toEntityMetadataInput
+};
+//# sourceMappingURL=index.mjs.map