@xrmforge/typegen 0.1.0

package/dist/index.js

@@ -0,0 +1,2281 @@
+// src/errors.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["AUTH_MISSING_CONFIG"] = "AUTH_1001";
+  ErrorCode2["AUTH_INVALID_CREDENTIALS"] = "AUTH_1002";
+  ErrorCode2["AUTH_TOKEN_FAILED"] = "AUTH_1003";
+  ErrorCode2["AUTH_TOKEN_EXPIRED"] = "AUTH_1004";
+  ErrorCode2["API_REQUEST_FAILED"] = "API_2001";
+  ErrorCode2["API_RATE_LIMITED"] = "API_2002";
+  ErrorCode2["API_NOT_FOUND"] = "API_2003";
+  ErrorCode2["API_UNAUTHORIZED"] = "API_2004";
+  ErrorCode2["API_TIMEOUT"] = "API_2005";
+  ErrorCode2["META_ENTITY_NOT_FOUND"] = "META_3001";
+  ErrorCode2["META_SOLUTION_NOT_FOUND"] = "META_3002";
+  ErrorCode2["META_FORM_PARSE_FAILED"] = "META_3003";
+  ErrorCode2["META_ATTRIBUTE_UNKNOWN_TYPE"] = "META_3004";
+  ErrorCode2["GEN_OUTPUT_WRITE_FAILED"] = "GEN_4001";
+  ErrorCode2["GEN_TEMPLATE_FAILED"] = "GEN_4002";
+  ErrorCode2["GEN_INVALID_IDENTIFIER"] = "GEN_4003";
+  ErrorCode2["CONFIG_INVALID"] = "CONFIG_5001";
+  ErrorCode2["CONFIG_FILE_NOT_FOUND"] = "CONFIG_5002";
+  ErrorCode2["CONFIG_ENV_VAR_MISSING"] = "CONFIG_5003";
+  return ErrorCode2;
+})(ErrorCode || {});
+var XrmForgeError = class _XrmForgeError extends Error {
+  code;
+  context;
+  constructor(code, message, context = {}) {
+    super(`[${code}] ${message}`);
+    this.name = "XrmForgeError";
+    this.code = code;
+    this.context = context;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _XrmForgeError);
+    }
+  }
+};
+var AuthenticationError = class extends XrmForgeError {
+  constructor(code, message, context = {}) {
+    super(code, message, context);
+    this.name = "AuthenticationError";
+  }
+};
+var ApiRequestError = class extends XrmForgeError {
+  statusCode;
+  responseBody;
+  constructor(code, message, context = {}) {
+    super(code, message, context);
+    this.name = "ApiRequestError";
+    this.statusCode = context.statusCode;
+    this.responseBody = context.responseBody;
+  }
+};
+var MetadataError = class extends XrmForgeError {
+  constructor(code, message, context = {}) {
+    super(code, message, context);
+    this.name = "MetadataError";
+  }
+};
+var GenerationError = class extends XrmForgeError {
+  constructor(code, message, context = {}) {
+    super(code, message, context);
+    this.name = "GenerationError";
+  }
+};
+var ConfigError = class extends XrmForgeError {
+  constructor(code, message, context = {}) {
+    super(code, message, context);
+    this.name = "ConfigError";
+  }
+};
+function isXrmForgeError(error) {
+  return error instanceof XrmForgeError;
+}
+function isRateLimitError(error) {
+  return error instanceof ApiRequestError && error.code === "API_2002" /* API_RATE_LIMITED */;
+}
+
+// src/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
+  return LogLevel2;
+})(LogLevel || {});
+var ConsoleLogSink = class _ConsoleLogSink {
+  static LEVEL_PREFIX = {
+    [0 /* DEBUG */]: "\x1B[90m[DBG]\x1B[0m",
+    [1 /* INFO */]: "\x1B[36m[INF]\x1B[0m",
+    [2 /* WARN */]: "\x1B[33m[WRN]\x1B[0m",
+    [3 /* ERROR */]: "\x1B[31m[ERR]\x1B[0m",
+    [4 /* SILENT */]: ""
+  };
+  write(entry) {
+    if (entry.level === 4 /* SILENT */) return;
+    const prefix = _ConsoleLogSink.LEVEL_PREFIX[entry.level];
+    const scope = `\x1B[90m[${entry.scope}]\x1B[0m`;
+    const message = `${prefix} ${scope} ${entry.message}`;
+    switch (entry.level) {
+      case 3 /* ERROR */:
+        console.error(message);
+        break;
+      case 2 /* WARN */:
+        console.warn(message);
+        break;
+      default:
+        console.log(message);
+    }
+    if (entry.context && entry.level === 0 /* DEBUG */) {
+      console.log("   Context:", JSON.stringify(entry.context, null, 2));
+    }
+  }
+  writeProgress(message) {
+    process.stdout.write(message);
+  }
+  writeProgressEnd(message) {
+    console.log(message);
+  }
+};
+var JsonLogSink = class {
+  write(entry) {
+    if (entry.level === 4 /* SILENT */) return;
+    const output = {
+      timestamp: entry.timestamp.toISOString(),
+      level: LogLevel[entry.level],
+      scope: entry.scope,
+      message: entry.message,
+      ...entry.context ? { context: entry.context } : {}
+    };
+    console.log(JSON.stringify(output));
+  }
+  writeProgress(message) {
+    console.log(JSON.stringify({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level: "INFO",
+      scope: "progress",
+      message: message.trim()
+    }));
+  }
+  writeProgressEnd(message) {
+    console.log(JSON.stringify({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level: "INFO",
+      scope: "progress",
+      message: message.trim()
+    }));
+  }
+};
+var SilentLogSink = class {
+  write(_entry) {
+  }
+  writeProgress(_message) {
+  }
+  writeProgressEnd(_message) {
+  }
+};
+var Logger = class {
+  scope;
+  getSink;
+  getMinLevel;
+  constructor(scope, getSink, getMinLevel) {
+    this.scope = scope;
+    this.getSink = getSink;
+    this.getMinLevel = getMinLevel;
+  }
+  debug(message, context) {
+    this.log(0 /* DEBUG */, message, context);
+  }
+  info(message, context) {
+    this.log(1 /* INFO */, message, context);
+  }
+  warn(message, context) {
+    this.log(2 /* WARN */, message, context);
+  }
+  error(message, context) {
+    this.log(3 /* ERROR */, message, context);
+  }
+  /**
+   * Write an inline progress update (no newline).
+   */
+  progress(message) {
+    if (this.getMinLevel() > 1 /* INFO */) return;
+    this.getSink().writeProgress(message);
+  }
+  /**
+   * Complete an inline progress line.
+   */
+  progressEnd(message) {
+    if (this.getMinLevel() > 1 /* INFO */) return;
+    this.getSink().writeProgressEnd(message);
+  }
+  log(level, message, context) {
+    if (level < this.getMinLevel()) return;
+    this.getSink().write({
+      level,
+      scope: this.scope,
+      message,
+      context,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+};
+var _sharedSink = new ConsoleLogSink();
+var _sharedMinLevel = 1 /* INFO */;
+function configureLogging(options) {
+  if (options.sink !== void 0) _sharedSink = options.sink;
+  if (options.minLevel !== void 0) _sharedMinLevel = options.minLevel;
+}
+function createLogger(scope) {
+  return new Logger(
+    scope,
+    () => _sharedSink,
+    () => _sharedMinLevel
+  );
+}
+
+// src/auth/credential.ts
+import {
+  ClientSecretCredential,
+  InteractiveBrowserCredential,
+  DeviceCodeCredential
+} from "@azure/identity";
+var log = createLogger("auth");
+var DEFAULT_CLIENT_ID = "51f81489-12ee-4a9e-aaae-a2591f45987d";
+function createCredential(config) {
+  switch (config.method) {
+    case "client-credentials":
+      return createClientCredential(config);
+    case "interactive":
+      return createInteractiveCredential(config);
+    case "device-code":
+      return createDeviceCodeCredential(config);
+    case "token":
+      return createStaticTokenCredential(config);
+    default: {
+      const exhaustiveCheck = config;
+      throw new AuthenticationError(
+        "AUTH_1001" /* AUTH_MISSING_CONFIG */,
+        `Unknown authentication method: "${exhaustiveCheck.method}". Supported methods: client-credentials, interactive, device-code.`
+      );
+    }
+  }
+}
+function createClientCredential(config) {
+  const missing = [];
+  if (!config.tenantId?.trim()) missing.push("tenantId");
+  if (!config.clientId?.trim()) missing.push("clientId");
+  if (!config.clientSecret?.trim()) missing.push("clientSecret");
+  if (missing.length > 0) {
+    throw new AuthenticationError(
+      "AUTH_1001" /* AUTH_MISSING_CONFIG */,
+      `Client credentials authentication requires: ${missing.join(", ")}. These can be set in xrmforge.config.json or via environment variables (XRMFORGE_TENANT_ID, XRMFORGE_CLIENT_ID, XRMFORGE_CLIENT_SECRET).`,
+      { missingFields: missing }
+    );
+  }
+  log.debug("Creating client credentials (Service Principal)", {
+    tenantId: config.tenantId,
+    clientId: config.clientId
+  });
+  return new ClientSecretCredential(config.tenantId, config.clientId, config.clientSecret);
+}
+function createInteractiveCredential(config) {
+  const clientId = config.clientId?.trim() || DEFAULT_CLIENT_ID;
+  log.debug("Creating interactive browser credential", {
+    clientId,
+    tenantId: config.tenantId ?? "common",
+    usingDefaultClientId: !config.clientId
+  });
+  return new InteractiveBrowserCredential({
+    tenantId: config.tenantId,
+    clientId
+  });
+}
+function createDeviceCodeCredential(config) {
+  const clientId = config.clientId?.trim() || DEFAULT_CLIENT_ID;
+  log.debug("Creating device code credential", {
+    clientId,
+    tenantId: config.tenantId ?? "common",
+    usingDefaultClientId: !config.clientId
+  });
+  return new DeviceCodeCredential({
+    tenantId: config.tenantId,
+    clientId,
+    userPromptCallback: (info) => {
+      log.info("Device Code Authentication required:");
+      log.info(info.message);
+    }
+  });
+}
+function createStaticTokenCredential(config) {
+  if (!config.token?.trim()) {
+    throw new AuthenticationError(
+      "AUTH_1001" /* AUTH_MISSING_CONFIG */,
+      "Token authentication requires a non-empty token. Set XRMFORGE_TOKEN environment variable or use --token flag."
+    );
+  }
+  log.debug("Using pre-acquired token (static credential)");
+  return new StaticTokenCredential(config.token);
+}
+var StaticTokenCredential = class {
+  token;
+  constructor(token) {
+    this.token = token;
+  }
+  async getToken() {
+    return {
+      token: this.token,
+      expiresOnTimestamp: Date.now() + 60 * 60 * 1e3
+      // Pretend 1 hour validity
+    };
+  }
+};
+
+// src/http/client.ts
+var log2 = createLogger("http");
+var TOKEN_BUFFER_MS = 5 * 60 * 1e3;
+var MAX_BACKOFF_MS = 6e4;
+var MAX_RESPONSE_BODY_LENGTH = 2e3;
+var MAX_ERROR_VALUE_LENGTH = 100;
+var DEFAULT_MAX_RATE_LIMIT_RETRIES = 10;
+var DataverseHttpClient = class {
+  baseUrl;
+  apiVersion;
+  credential;
+  maxRetries;
+  retryBaseDelayMs;
+  timeoutMs;
+  maxConcurrency;
+  maxPages;
+  maxRateLimitRetries;
+  readOnly;
+  cachedToken = null;
+  // Semaphore for concurrency control (non-recursive)
+  activeConcurrentRequests = 0;
+  waitQueue = [];
+  constructor(options) {
+    this.baseUrl = options.environmentUrl.replace(/\/$/, "");
+    this.apiVersion = options.apiVersion ?? "v9.2";
+    this.credential = options.credential;
+    this.maxRetries = options.maxRetries ?? 3;
+    this.retryBaseDelayMs = options.retryBaseDelayMs ?? 1e3;
+    this.timeoutMs = options.timeoutMs ?? 3e4;
+    this.maxConcurrency = options.maxConcurrency ?? 5;
+    this.maxPages = options.maxPages ?? 100;
+    this.maxRateLimitRetries = options.maxRateLimitRetries ?? DEFAULT_MAX_RATE_LIMIT_RETRIES;
+    this.readOnly = options.readOnly ?? true;
+  }
+  /**
+   * Full API base URL, e.g. "https://myorg.crm4.dynamics.com/api/data/v9.2"
+   */
+  get apiUrl() {
+    return `${this.baseUrl}/api/data/${this.apiVersion}`;
+  }
+  // ─── Public API ──────────────────────────────────────────────────────────
+  /**
+   * Execute a GET request against the Dataverse Web API.
+   * Handles token caching, retries, rate limits, and timeout.
+   *
+   * @param path - API path (relative or absolute URL)
+   * @param signal - Optional AbortSignal to cancel the request
+   */
+  async get(path2, signal) {
+    const url = this.resolveUrl(path2);
+    return this.executeWithConcurrency(url, signal);
+  }
+  /**
+   * Execute a GET request and automatically follow @odata.nextLink for paging.
+   * Returns all pages combined into a single array.
+   *
+   * Safety: Stops after `maxPages` iterations to prevent infinite loops.
+   *
+   * @param path - API path (relative or absolute URL)
+   * @param signal - Optional AbortSignal to cancel the request
+   */
+  async getAll(path2, signal) {
+    const allResults = [];
+    let currentUrl = this.resolveUrl(path2);
+    let page = 0;
+    while (currentUrl) {
+      if (signal?.aborted) {
+        throw new ApiRequestError(
+          "API_2001" /* API_REQUEST_FAILED */,
+          `Request aborted after ${page} pages (${allResults.length} records retrieved)`,
+          { url: currentUrl, pagesCompleted: page }
+        );
+      }
+      page++;
+      if (page > this.maxPages) {
+        log2.warn(
+          `Stopped paging after ${this.maxPages} pages (safety limit). ${allResults.length} records retrieved. Increase maxPages if this is expected.`
+        );
+        break;
+      }
+      const response = await this.executeWithConcurrency(currentUrl, signal);
+      allResults.push(...response.value);
+      currentUrl = response["@odata.nextLink"] ?? null;
+      if (currentUrl) {
+        log2.debug(`Following @odata.nextLink (page ${page}), ${allResults.length} records so far`);
+      }
+    }
+    return allResults;
+  }
+  // ─── Read-Only Enforcement ─────────────────────────────────────────────
+  /**
+   * Returns true if this client is in read-only mode (the safe default).
+   */
+  get isReadOnly() {
+    return this.readOnly;
+  }
+  /**
+   * Assert that a non-GET operation is allowed.
+   * Throws immediately if the client is in read-only mode.
+   *
+   * @throws {ApiRequestError} always in read-only mode
+   * @internal This method exists so that future packages (e.g. @xrmforge/webapi)
+   * can reuse the HTTP client for write operations when readOnly is explicitly false.
+   */
+  assertWriteAllowed(operation) {
+    if (this.readOnly) {
+      throw new ApiRequestError(
+        "API_2001" /* API_REQUEST_FAILED */,
+        `BLOCKED: Write operation "${operation}" rejected. This client is in read-only mode (readOnly: true). XrmForge typegen must NEVER modify data in Dataverse. Set readOnly: false only for @xrmforge/webapi (not for typegen).`,
+        { operation, readOnly: true }
+      );
+    }
+  }
+  // ─── Input Sanitization ──────────────────────────────────────────────────
+  /**
+   * Validate that a value is a safe OData identifier (entity name, attribute name).
+   * Prevents OData injection by allowing only: starts with letter/underscore,
+   * followed by alphanumeric/underscore.
+   *
+   * @throws {ApiRequestError} if the value contains invalid characters
+   */
+  static sanitizeIdentifier(value) {
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value)) {
+      throw new ApiRequestError(
+        "API_2001" /* API_REQUEST_FAILED */,
+        `Invalid OData identifier: "${value.substring(0, MAX_ERROR_VALUE_LENGTH).replace(/[\r\n]/g, "")}". Only letters, digits, and underscores allowed; must start with a letter or underscore.`,
+        { value: value.substring(0, MAX_ERROR_VALUE_LENGTH) }
+      );
+    }
+    return value;
+  }
+  /**
+   * Validate that a value is a properly formatted GUID.
+   *
+   * @throws {ApiRequestError} if the format is invalid
+   */
+  static sanitizeGuid(value) {
+    const guidPattern = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+    if (!guidPattern.test(value)) {
+      throw new ApiRequestError(
+        "API_2001" /* API_REQUEST_FAILED */,
+        `Invalid GUID format: "${value}".`,
+        { value }
+      );
+    }
+    return value;
+  }
+  /**
+   * Escape a string for use inside OData single-quoted string literals.
+   * Doubles single quotes to prevent injection.
+   */
+  static escapeODataString(value) {
+    return value.replace(/'/g, "''");
+  }
+  // ─── Token Management ────────────────────────────────────────────────────
+  async getToken() {
+    if (this.cachedToken && this.cachedToken.expiresAt - Date.now() > TOKEN_BUFFER_MS) {
+      return this.cachedToken.token;
+    }
+    log2.debug("Requesting new access token");
+    const scope = `${this.baseUrl}/.default`;
+    let tokenResponse;
+    try {
+      tokenResponse = await this.credential.getToken(scope);
+    } catch (error) {
+      throw new AuthenticationError(
+        "AUTH_1003" /* AUTH_TOKEN_FAILED */,
+        `Failed to acquire access token for ${this.baseUrl}. Verify your authentication configuration.`,
+        {
+          environmentUrl: this.baseUrl,
+          originalError: error instanceof Error ? error.message : String(error)
+        }
+      );
+    }
+    if (!tokenResponse) {
+      throw new AuthenticationError(
+        "AUTH_1003" /* AUTH_TOKEN_FAILED */,
+        `No access token returned for ${this.baseUrl}. This may indicate invalid credentials or insufficient permissions.`,
+        { environmentUrl: this.baseUrl }
+      );
+    }
+    this.cachedToken = {
+      token: tokenResponse.token,
+      expiresAt: tokenResponse.expiresOnTimestamp
+    };
+    log2.debug("Access token acquired", {
+      expiresIn: `${Math.round((tokenResponse.expiresOnTimestamp - Date.now()) / 1e3)}s`
+    });
+    return tokenResponse.token;
+  }
+  // ─── Concurrency Control ─────────────────────────────────────────────────
+  /**
+   * Execute a request within the concurrency semaphore.
+   * The semaphore is acquired ONCE per logical request. Retries happen
+   * INSIDE the semaphore to avoid the recursive slot exhaustion bug.
+   */
+  async executeWithConcurrency(url, signal) {
+    await this.acquireSlot();
+    try {
+      return await this.executeWithRetry(url, 1, 0, signal);
+    } finally {
+      this.releaseSlot();
+    }
+  }
+  acquireSlot() {
+    if (this.activeConcurrentRequests < this.maxConcurrency) {
+      this.activeConcurrentRequests++;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.waitQueue.push(() => {
+        this.activeConcurrentRequests++;
+        resolve();
+      });
+    });
+  }
+  releaseSlot() {
+    this.activeConcurrentRequests--;
+    const next = this.waitQueue.shift();
+    if (next) next();
+  }
+  // ─── Retry Logic (runs INSIDE a single concurrency slot) ─────────────────
+  async executeWithRetry(url, attempt, rateLimitRetries = 0, signal) {
+    if (signal?.aborted) {
+      throw new ApiRequestError(
+        "API_2001" /* API_REQUEST_FAILED */,
+        "Request aborted before execution",
+        { url }
+      );
+    }
+    const token = await this.getToken();
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+    const onUserAbort = () => controller.abort();
+    signal?.addEventListener("abort", onUserAbort, { once: true });
+    let response;
+    try {
+      log2.debug(`GET ${url}`, { attempt });
+      response = await fetch(url, {
+        method: "GET",
+        // Explicit: never rely on default
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "OData-MaxVersion": "4.0",
+          "OData-Version": "4.0",
+          Accept: "application/json",
+          Prefer: 'odata.include-annotations="*"'
+        },
+        signal: controller.signal
+      });
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+      signal?.removeEventListener("abort", onUserAbort);
+      if (fetchError instanceof Error && fetchError.name === "AbortError") {
+        if (signal?.aborted) {
+          throw new ApiRequestError(
+            "API_2001" /* API_REQUEST_FAILED */,
+            "Request aborted by caller",
+            { url, attempt }
+          );
+        }
+        if (attempt <= this.maxRetries) {
+          const delay = this.calculateBackoff(attempt);
+          log2.warn(`Request timed out, retrying in ${delay}ms (${attempt}/${this.maxRetries})`, {
+            url
+          });
+          await this.sleep(delay);
+          return this.executeWithRetry(url, attempt + 1, rateLimitRetries, signal);
+        }
+        throw new ApiRequestError(
+          "API_2005" /* API_TIMEOUT */,
+          `Request timed out after ${this.timeoutMs}ms (${this.maxRetries} retries exhausted)`,
+          { url, timeoutMs: this.timeoutMs }
+        );
+      }
+      if (attempt <= this.maxRetries) {
+        const delay = this.calculateBackoff(attempt);
+        log2.warn(`Network error, retrying in ${delay}ms (${attempt}/${this.maxRetries})`, {
+          url,
+          error: fetchError instanceof Error ? fetchError.message : String(fetchError)
+        });
+        await this.sleep(delay);
+        return this.executeWithRetry(url, attempt + 1, rateLimitRetries, signal);
+      }
+      throw new ApiRequestError(
+        "API_2001" /* API_REQUEST_FAILED */,
+        `Network error after ${this.maxRetries} retries`,
+        {
+          url,
+          originalError: fetchError instanceof Error ? fetchError.message : String(fetchError)
+        }
+      );
+    } finally {
+      clearTimeout(timeoutId);
+      signal?.removeEventListener("abort", onUserAbort);
+    }
+    if (!response.ok) {
+      return this.handleHttpError(response, url, attempt, rateLimitRetries, signal);
+    }
+    log2.debug(`GET ${url} -> ${response.status}`, { attempt });
+    return response.json();
+  }
+  async handleHttpError(response, url, attempt, rateLimitRetries, signal) {
+    const body = await response.text();
+    if (response.status === 429) {
+      if (rateLimitRetries >= this.maxRateLimitRetries) {
+        throw new ApiRequestError(
+          "API_2002" /* API_RATE_LIMITED */,
+          `Rate limit retries exhausted (${this.maxRateLimitRetries} consecutive 429 responses)`,
+          { url, rateLimitRetries }
+        );
+      }
+      const retryAfterHeader = response.headers.get("Retry-After");
+      const retryAfterMs = retryAfterHeader ? parseInt(retryAfterHeader, 10) * 1e3 : this.calculateBackoff(rateLimitRetries + 1);
+      log2.warn(`Rate limited (HTTP 429). Waiting ${retryAfterMs}ms (${rateLimitRetries + 1}/${this.maxRateLimitRetries}).`, {
+        url,
+        retryAfterHeader
+      });
+      await this.sleep(retryAfterMs);
+      return this.executeWithRetry(url, attempt, rateLimitRetries + 1, signal);
+    }
+    if (response.status === 401 && attempt === 1) {
+      log2.warn("HTTP 401 received, clearing token cache and retrying");
+      this.cachedToken = null;
+      return this.executeWithRetry(url, attempt + 1, 0, signal);
+    }
+    if (response.status >= 500 && attempt <= this.maxRetries) {
+      const delay = this.calculateBackoff(attempt);
+      log2.warn(
+        `Server error ${response.status}, retrying in ${delay}ms (${attempt}/${this.maxRetries})`
+      );
+      await this.sleep(delay);
+      return this.executeWithRetry(url, attempt + 1, rateLimitRetries, signal);
+    }
+    const errorCode = response.status === 401 ? "API_2004" /* API_UNAUTHORIZED */ : response.status === 404 ? "API_2003" /* API_NOT_FOUND */ : "API_2001" /* API_REQUEST_FAILED */;
+    throw new ApiRequestError(
+      errorCode,
+      `Dataverse API error: HTTP ${response.status} ${response.statusText}`,
+      {
+        url,
+        statusCode: response.status,
+        responseBody: body.substring(0, MAX_RESPONSE_BODY_LENGTH)
+      }
+    );
+  }
+  // ─── Helpers ─────────────────────────────────────────────────────────────
+  resolveUrl(path2) {
+    return path2.startsWith("http") ? path2 : `${this.apiUrl}${path2}`;
+  }
+  calculateBackoff(attempt) {
+    const exponential = this.retryBaseDelayMs * Math.pow(2, attempt - 1);
+    const jitter = Math.random() * this.retryBaseDelayMs;
+    return Math.min(exponential + jitter, MAX_BACKOFF_MS);
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/metadata/xml-parser.ts
+import { XMLParser } from "fast-xml-parser";
+var FastXmlParser = class {
+  parser;
+  constructor() {
+    this.parser = new XMLParser({
+      ignoreAttributes: false,
+      attributeNamePrefix: "@_",
+      allowBooleanAttributes: true,
+      preserveOrder: true,
+      trimValues: true
+    });
+  }
+  parse(xml) {
+    const result = this.parser.parse(xml);
+    return this.convertToXmlElement(result);
+  }
+  convertToXmlElement(parsed) {
+    if (!Array.isArray(parsed) || parsed.length === 0) {
+      return { tag: "root", attributes: {}, children: [] };
+    }
+    const children = parsed.map((item) => this.convertNode(item));
+    if (children.length === 1) {
+      return children[0];
+    }
+    return { tag: "root", attributes: {}, children };
+  }
+  convertNode(node) {
+    const attrs = {};
+    let tag = "";
+    let children = [];
+    let text;
+    for (const key of Object.keys(node)) {
+      if (key === ":@") {
+        const attrObj = node[key];
+        for (const [attrKey, attrVal] of Object.entries(attrObj)) {
+          const cleanKey = attrKey.startsWith("@_") ? attrKey.slice(2) : attrKey;
+          attrs[cleanKey] = String(attrVal);
+        }
+      } else if (key === "#text") {
+        text = String(node[key]);
+      } else {
+        tag = key;
+        const childContent = node[key];
+        if (Array.isArray(childContent)) {
+          children = childContent.map((child) => this.convertNode(child));
+        }
+      }
+    }
+    return { tag, attributes: attrs, children, text };
+  }
+};
+var defaultXmlParser = new FastXmlParser();
+
+// src/metadata/form-parser.ts
+var log3 = createLogger("form-parser");
+var SPECIAL_CONTROL_CLASSIDS = {
+  // Subgrid (read-only list of related records)
+  "e7a81278-8635-4d9e-8d4d-59480b391c5b": "subgrid",
+  // Editable Grid (inline-editable list)
+  "02d4264b-47e2-4b4c-aa95-f439f3f4d458": "editablegrid",
+  // Quick View Form (embedded read-only form of related record)
+  "5c5600e0-1d6e-4205-a272-be80da87fd42": "quickview",
+  // Web Resource (custom HTML/JS content)
+  "9fdf5f91-88b1-47f4-ad53-c11efc01a01d": "webresource",
+  // Bing Map
+  "62b0df79-0464-470f-8af7-4483cfea0c7d": "map",
+  // Notes/Timeline
+  "06375649-c143-495e-a496-c962e5b4488e": "notes"
+};
+function parseForm(form, parser = defaultXmlParser) {
+  const tabs = parseTabs(form.formxml, form.name, parser);
+  const allControls = tabs.flatMap(
+    (tab) => tab.sections.flatMap((section) => section.controls)
+  );
+  const allSpecialControls = tabs.flatMap(
+    (tab) => tab.sections.flatMap((section) => section.specialControls)
+  );
+  return {
+    name: form.name,
+    formId: form.formid,
+    isDefault: form.isdefault,
+    tabs,
+    allControls,
+    allSpecialControls
+  };
+}
+function extractControlFields(formxml, parser = defaultXmlParser) {
+  if (!formxml || formxml.trim().length === 0) {
+    return [];
+  }
+  try {
+    const root = parser.parse(formxml);
+    const fields = [];
+    collectDatafieldNames(root, fields);
+    return fields;
+  } catch {
+    log3.warn("Failed to parse formxml for field extraction, returning empty list");
+    return [];
+  }
+}
+function parseTabs(formxml, formName, parser) {
+  if (!formxml || formxml.trim().length === 0) {
+    log3.warn(`Empty formxml for form "${formName}"`);
+    return [];
+  }
+  let root;
+  try {
+    root = parser.parse(formxml);
+  } catch (error) {
+    throw new MetadataError(
+      "META_3003" /* META_FORM_PARSE_FAILED */,
+      `Failed to parse FormXml for form "${formName}"`,
+      {
+        formName,
+        originalError: error instanceof Error ? error.message : String(error)
+      }
+    );
+  }
+  const tabs = [];
+  const tabElements = findElements(root, "tab");
+  for (const tabEl of tabElements) {
+    const tabName = tabEl.attributes["name"] ?? "";
+    const tabVisible = tabEl.attributes["visible"] !== "false";
+    const tabLabel = extractLabel(tabEl);
+    const sections = parseSections(tabEl);
+    tabs.push({ name: tabName, label: tabLabel, visible: tabVisible, sections });
+  }
+  return tabs;
+}
+function parseSections(tabElement) {
+  const sections = [];
+  const sectionElements = findElements(tabElement, "section");
+  for (const sectionEl of sectionElements) {
+    const sectionName = sectionEl.attributes["name"] ?? "";
+    const sectionVisible = sectionEl.attributes["visible"] !== "false";
+    const sectionLabel = extractLabel(sectionEl);
+    const controls = parseDataControls(sectionEl);
+    const specialControls = parseSpecialControls(sectionEl);
+    sections.push({
+      name: sectionName,
+      label: sectionLabel,
+      visible: sectionVisible,
+      controls,
+      specialControls
+    });
+  }
+  return sections;
+}
+function parseDataControls(sectionElement) {
+  const controls = [];
+  const controlElements = findElements(sectionElement, "control");
+  for (const controlEl of controlElements) {
+    const datafieldname = controlEl.attributes["datafieldname"];
+    if (!datafieldname) continue;
+    controls.push({
+      id: controlEl.attributes["id"] ?? "",
+      datafieldname,
+      classid: controlEl.attributes["classid"] ?? ""
+    });
+  }
+  return controls;
+}
+function parseSpecialControls(sectionElement) {
+  const controls = [];
+  const controlElements = findElements(sectionElement, "control");
+  for (const controlEl of controlElements) {
+    if (controlEl.attributes["datafieldname"]) continue;
+    const classid = (controlEl.attributes["classid"] ?? "").replace(/[{}]/g, "").toLowerCase();
+    const controlType = SPECIAL_CONTROL_CLASSIDS[classid];
+    if (!controlType) continue;
+    const special = {
+      id: controlEl.attributes["id"] ?? "",
+      classid,
+      controlType
+    };
+    if (controlType === "subgrid" || controlType === "editablegrid") {
+      special.targetEntityType = extractParameter(controlEl, "TargetEntityType");
+      special.relationshipName = extractParameter(controlEl, "RelationshipName");
+    }
+    if (controlType === "webresource") {
+      special.webResourceName = extractParameter(controlEl, "Url");
+    }
+    controls.push(special);
+  }
+  return controls;
+}
+function findElements(element, tagName) {
+  const results = [];
+  if (element.tag === tagName) {
+    results.push(element);
+  }
+  for (const child of element.children) {
+    results.push(...findElements(child, tagName));
+  }
+  return results;
+}
+function collectDatafieldNames(element, fields) {
+  if (element.tag === "control") {
+    const name = element.attributes["datafieldname"];
+    if (name && !fields.includes(name)) {
+      fields.push(name);
+    }
+  }
+  for (const child of element.children) {
+    collectDatafieldNames(child, fields);
+  }
+}
+function extractLabel(element) {
+  const labelsEl = element.children.find((c) => c.tag === "labels");
+  if (!labelsEl) return void 0;
+  const labelEl = labelsEl.children.find((c) => c.tag === "label");
+  if (!labelEl) return void 0;
+  return labelEl.attributes["description"] || void 0;
+}
+function extractParameter(controlElement, paramName) {
+  const paramsEl = controlElement.children.find((c) => c.tag === "parameters");
+  if (!paramsEl) return void 0;
+  const paramEl = paramsEl.children.find((c) => c.tag === paramName);
+  if (!paramEl) return void 0;
+  return paramEl.text || void 0;
+}
+
+// src/metadata/client.ts
+var log4 = createLogger("metadata");
+var FORM_TYPE_MAIN = 2;
+var COMPONENT_TYPE_ENTITY = 1;
+var ENTITY_SELECT = "LogicalName,SchemaName,EntitySetName,DisplayName,PrimaryIdAttribute,PrimaryNameAttribute,OwnershipType,IsCustomEntity,LogicalCollectionName,MetadataId";
+var ATTRIBUTE_SELECT = "LogicalName,SchemaName,AttributeType,AttributeTypeName,DisplayName,IsPrimaryId,IsPrimaryName,RequiredLevel,IsValidForRead,IsValidForCreate,IsValidForUpdate,MetadataId";
+var FORM_SELECT = "name,formid,formxml,description,isdefault";
+var MetadataClient = class {
+  http;
+  constructor(httpClient) {
+    this.http = httpClient;
+  }
+  // ─── Entity Metadata ───────────────────────────────────────────────────
+  /**
+   * Get metadata for a single entity by LogicalName, including all attributes.
+   *
+   * @throws {MetadataError} if the entity is not found
+   */
+  async getEntityWithAttributes(logicalName) {
+    const safeName = DataverseHttpClient.sanitizeIdentifier(logicalName);
+    log4.info(`Fetching entity metadata: ${safeName}`);
+    const entity = await this.http.get(
+      `/EntityDefinitions(LogicalName='${safeName}')?$select=${ENTITY_SELECT}&$expand=Attributes($select=${ATTRIBUTE_SELECT})`
+    );
+    log4.info(`Entity "${safeName}": ${entity.Attributes?.length ?? 0} attributes`);
+    return entity;
+  }
+  /**
+   * List all entities (without attributes) for discovery.
+   * Use `$filter` parameter to narrow results.
+   */
+  async listEntities(filter) {
+    let path2 = `/EntityDefinitions?$select=${ENTITY_SELECT}`;
+    if (filter) {
+      path2 += `&$filter=${filter}`;
+    }
+    log4.info("Listing entities");
+    return this.http.getAll(path2);
+  }
+  // ─── Typed Attribute Queries ───────────────────────────────────────────
+  /**
+   * Get all Picklist attributes with their OptionSets for an entity.
+   * Includes both local and global OptionSets.
+   */
+  async getPicklistAttributes(logicalName) {
+    const safeName = DataverseHttpClient.sanitizeIdentifier(logicalName);
+    log4.debug(`Fetching Picklist attributes for: ${safeName}`);
+    return this.http.getAll(
+      `/EntityDefinitions(LogicalName='${safeName}')/Attributes/Microsoft.Dynamics.CRM.PicklistAttributeMetadata?$select=LogicalName,SchemaName,MetadataId&$expand=OptionSet($select=Options,Name,IsGlobal,MetadataId),GlobalOptionSet($select=Options,Name,MetadataId)`
+    );
+  }
+  /**
+   * Get all Lookup attributes with their target entity names.
+   */
+  async getLookupAttributes(logicalName) {
+    const safeName = DataverseHttpClient.sanitizeIdentifier(logicalName);
+    log4.debug(`Fetching Lookup attributes for: ${safeName}`);
+    return this.http.getAll(
+      `/EntityDefinitions(LogicalName='${safeName}')/Attributes/Microsoft.Dynamics.CRM.LookupAttributeMetadata?$select=LogicalName,SchemaName,Targets,MetadataId`
+    );
+  }
+  /**
+   * Get Status attributes (statuscode) with their OptionSets.
+   */
+  async getStatusAttributes(logicalName) {
+    const safeName = DataverseHttpClient.sanitizeIdentifier(logicalName);
+    log4.debug(`Fetching Status attributes for: ${safeName}`);
+    return this.http.getAll(
+      `/EntityDefinitions(LogicalName='${safeName}')/Attributes/Microsoft.Dynamics.CRM.StatusAttributeMetadata?$select=LogicalName,SchemaName,MetadataId&$expand=OptionSet($select=Options)`
+    );
+  }
+  /**
+   * Get State attributes (statecode) with their OptionSets.
+   */
+  async getStateAttributes(logicalName) {
+    const safeName = DataverseHttpClient.sanitizeIdentifier(logicalName);
+    log4.debug(`Fetching State attributes for: ${safeName}`);
+    return this.http.getAll(
+      `/EntityDefinitions(LogicalName='${safeName}')/Attributes/Microsoft.Dynamics.CRM.StateAttributeMetadata?$select=LogicalName,SchemaName,MetadataId&$expand=OptionSet($select=Options)`
+    );
+  }
+  // ─── Form Metadata ────────────────────────────────────────────────────
+  /**
+   * Get and parse Main forms (type=2) for an entity.
+   * Returns parsed form structures with tabs, sections, and controls.
+   */
+  async getMainForms(logicalName) {
+    const safeName = DataverseHttpClient.sanitizeIdentifier(logicalName);
+    log4.info(`Fetching Main forms for: ${safeName}`);
+    const forms = await this.http.getAll(
+      `/systemforms?$filter=objecttypecode eq '${safeName}' and type eq ${FORM_TYPE_MAIN}&$select=${FORM_SELECT}`
+    );
+    log4.info(`Found ${forms.length} Main form(s) for "${safeName}"`);
+    return forms.map((form) => {
+      try {
+        return parseForm(form);
+      } catch (error) {
+        log4.warn(`Failed to parse form "${form.name}" (${form.formid}), skipping`, {
+          formName: form.name,
+          formId: form.formid,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return {
+          name: form.name,
+          formId: form.formid,
+          isDefault: form.isdefault,
+          tabs: [],
+          allControls: [],
+          allSpecialControls: []
+        };
+      }
+    });
+  }
+  // ─── Global OptionSets ─────────────────────────────────────────────────
+  /**
+   * Get a global OptionSet by its exact name.
+   */
+  async getGlobalOptionSet(name) {
+    const safeName = DataverseHttpClient.sanitizeIdentifier(name);
+    log4.debug(`Fetching GlobalOptionSet: ${safeName}`);
+    return this.http.get(
+      `/GlobalOptionSetDefinitions(Name='${safeName}')`
+    );
+  }
+  /**
+   * List all global OptionSets (names and types only).
+   */
+  async listGlobalOptionSets() {
+    log4.debug("Listing all GlobalOptionSets");
+    return this.http.getAll(
+      `/GlobalOptionSetDefinitions?$select=Name,DisplayName,OptionSetType,IsGlobal,MetadataId`
+    );
+  }
+  // ─── Relationships ─────────────────────────────────────────────────────
+  /**
+   * Get all 1:N relationships where this entity is the referenced (parent) entity.
+   */
+  async getOneToManyRelationships(logicalName) {
+    const safeName = DataverseHttpClient.sanitizeIdentifier(logicalName);
+    log4.debug(`Fetching 1:N relationships for: ${safeName}`);
+    return this.http.getAll(
+      `/EntityDefinitions(LogicalName='${safeName}')/OneToManyRelationships?$select=SchemaName,ReferencingEntity,ReferencingAttribute,ReferencedEntity,ReferencedAttribute,MetadataId`
+    );
+  }
+  /**
+   * Get all N:N relationships for an entity.
+   */
+  async getManyToManyRelationships(logicalName) {
+    const safeName = DataverseHttpClient.sanitizeIdentifier(logicalName);
+    log4.debug(`Fetching N:N relationships for: ${safeName}`);
+    return this.http.getAll(
+      `/EntityDefinitions(LogicalName='${safeName}')/ManyToManyRelationships?$select=SchemaName,Entity1LogicalName,Entity2LogicalName,IntersectEntityName,MetadataId`
+    );
+  }
+  // ─── Solution Filter ───────────────────────────────────────────────────
+  /**
+   * Get all entity LogicalNames that belong to a specific solution.
+   * Resolves SolutionComponent MetadataIds to EntityDefinition LogicalNames.
+   *
+   * @param solutionUniqueName - The unique name of the solution
+   * @returns Array of entity LogicalNames (e.g. ["account", "contact"])
+   */
+  async getEntityNamesForSolution(solutionUniqueName) {
+    const safeName = DataverseHttpClient.escapeODataString(solutionUniqueName);
+    log4.info(`Fetching solution: ${solutionUniqueName}`);
+    const solutions = await this.http.get(
+      `/solutions?$filter=uniquename eq '${safeName}'&$select=solutionid,uniquename,friendlyname`
+    );
+    if (solutions.value.length === 0) {
+      throw new MetadataError(
+        "META_3002" /* META_SOLUTION_NOT_FOUND */,
+        `Solution "${solutionUniqueName}" not found`,
+        { solutionUniqueName }
+      );
+    }
+    const solutionId = solutions.value[0].solutionid;
+    const solutionName = solutions.value[0].friendlyname;
+    log4.info(`Solution "${solutionName}" (${solutionId})`);
+    const components = await this.http.getAll(
+      `/solutioncomponents?$filter=_solutionid_value eq ${DataverseHttpClient.sanitizeGuid(solutionId)} and componenttype eq ${COMPONENT_TYPE_ENTITY}&$select=objectid,componenttype`
+    );
+    log4.info(`Solution "${solutionName}" contains ${components.length} entity components`);
+    if (components.length === 0) return [];
+    const metadataIds = components.map((c) => c.objectid);
+    const filterClauses = metadataIds.map((id) => `MetadataId eq ${DataverseHttpClient.sanitizeGuid(id)}`);
+    const BATCH_SIZE = 15;
+    const logicalNames = [];
+    for (let i = 0; i < filterClauses.length; i += BATCH_SIZE) {
+      const batch = filterClauses.slice(i, i + BATCH_SIZE);
+      const filter = batch.join(" or ");
+      const entities = await this.http.getAll(
+        `/EntityDefinitions?$filter=${filter}&$select=LogicalName`
+      );
+      for (const e of entities) {
+        logicalNames.push(e.LogicalName);
+      }
+    }
+    log4.info(`Resolved ${logicalNames.length} entity logical names from solution "${solutionName}"`);
+    return logicalNames;
+  }
+  /**
+   * Get all entity LogicalNames from multiple solutions, merged and deduplicated.
+   *
+   * @param solutionUniqueNames - Array of solution unique names
+   * @returns Deduplicated array of entity LogicalNames
+   */
+  async getEntityNamesForSolutions(solutionUniqueNames) {
+    const allNames = /* @__PURE__ */ new Set();
+    for (const name of solutionUniqueNames) {
+      const names = await this.getEntityNamesForSolution(name);
+      for (const n of names) {
+        allNames.add(n);
+      }
+    }
+    const result = [...allNames].sort();
+    log4.info(`${result.length} unique entities from ${solutionUniqueNames.length} solutions`);
+    return result;
+  }
+  // ─── Aggregated Metadata ───────────────────────────────────────────────
+  /**
+   * Fetch complete metadata for a single entity: all attributes (typed),
+   * forms, and relationships. This is the primary method for type generation.
+   *
+   * Makes 7 parallel API calls per entity for optimal performance.
+   */
+  async getEntityTypeInfo(logicalName) {
+    const safeName = DataverseHttpClient.sanitizeIdentifier(logicalName);
+    log4.info(`Fetching complete type info for: ${safeName}`);
+    const [entity, picklistAttributes, lookupAttributes, statusAttributes, stateAttributes, forms, relationships] = await Promise.all([
+      this.getEntityWithAttributes(safeName),
+      this.getPicklistAttributes(safeName),
+      this.getLookupAttributes(safeName),
+      this.getStatusAttributes(safeName),
+      this.getStateAttributes(safeName),
+      this.getMainForms(safeName),
+      this.getRelationships(safeName)
+    ]);
+    const result = {
+      entity,
+      attributes: entity.Attributes ?? [],
+      picklistAttributes,
+      lookupAttributes,
+      statusAttributes,
+      stateAttributes,
+      forms,
+      oneToManyRelationships: relationships.oneToMany,
+      manyToManyRelationships: relationships.manyToMany
+    };
+    log4.info(
+      `Type info for "${safeName}": ${result.attributes.length} attrs, ${picklistAttributes.length} picklists, ${lookupAttributes.length} lookups, ${stateAttributes.length} state, ${forms.length} forms, ${relationships.oneToMany.length} 1:N, ${relationships.manyToMany.length} N:N`
+    );
+    return result;
+  }
+  /**
+   * Fetch complete metadata for multiple entities in parallel.
+   * Respects the HTTP client's concurrency limit automatically.
+   */
+  async getMultipleEntityTypeInfos(logicalNames) {
+    log4.info(`Fetching type info for ${logicalNames.length} entities`);
+    return Promise.all(logicalNames.map((name) => this.getEntityTypeInfo(name)));
+  }
+  // ─── Internal Helpers ──────────────────────────────────────────────────
+  async getRelationships(logicalName) {
+    const [oneToMany, manyToMany] = await Promise.all([
+      this.getOneToManyRelationships(logicalName),
+      this.getManyToManyRelationships(logicalName)
+    ]);
+    return { oneToMany, manyToMany };
+  }
+};
+
+// src/metadata/cache.ts
+import { promises as fs } from "fs";
+import * as path from "path";
+var log5 = createLogger("cache");
+var CACHE_DIR = ".xrmforge/cache";
+var CACHE_FILE = "metadata.json";
+var CACHE_VERSION = "1";
+var MetadataCache = class {
+  cacheDir;
+  cacheFilePath;
+  /**
+   * @param projectRoot - Root directory of the project (where .xrmforge/ will be created)
+   */
+  constructor(projectRoot) {
+    this.cacheDir = path.join(projectRoot, CACHE_DIR);
+    this.cacheFilePath = path.join(this.cacheDir, CACHE_FILE);
+  }
+  /**
+   * Load cached metadata from disk.
+   * Returns null if no cache exists, cache is for a different environment,
+   * or cache format is incompatible.
+   */
+  async load(environmentUrl) {
+    try {
+      const raw = await fs.readFile(this.cacheFilePath, "utf-8");
+      const data = JSON.parse(raw);
+      if (data.manifest.version !== CACHE_VERSION) {
+        log5.info("Cache version mismatch, will do full refresh");
+        return null;
+      }
+      if (data.manifest.environmentUrl !== environmentUrl) {
+        log5.info("Cache is for a different environment, will do full refresh", {
+          cached: data.manifest.environmentUrl,
+          current: environmentUrl
+        });
+        return null;
+      }
+      log5.info(`Loaded metadata cache: ${data.manifest.entities.length} entities, last refreshed ${data.manifest.lastRefreshed}`);
+      return data;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        log5.info("No metadata cache found, will do full refresh");
+      } else {
+        log5.warn("Failed to read metadata cache, will do full refresh", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      return null;
+    }
+  }
+  /**
+   * Save metadata to the file-system cache.
+   */
+  async save(environmentUrl, entityTypeInfos, serverVersionStamp) {
+    const data = {
+      manifest: {
+        version: CACHE_VERSION,
+        environmentUrl,
+        serverVersionStamp,
+        lastRefreshed: (/* @__PURE__ */ new Date()).toISOString(),
+        entities: Object.keys(entityTypeInfos).sort()
+      },
+      entityTypeInfos
+    };
+    await fs.mkdir(this.cacheDir, { recursive: true });
+    const tmpPath = this.cacheFilePath + ".tmp";
+    await fs.writeFile(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+    await fs.rename(tmpPath, this.cacheFilePath);
+    log5.info(`Saved metadata cache: ${data.manifest.entities.length} entities`);
+  }
+  /**
+   * Get the stored ServerVersionStamp for delta queries.
+   * Returns null if no cache exists.
+   */
+  async getVersionStamp(environmentUrl) {
+    const cache = await this.load(environmentUrl);
+    return cache?.manifest.serverVersionStamp ?? null;
+  }
+  /**
+   * Update specific entities in the cache (delta update).
+   * Merges new/changed entities into the existing cache.
+   */
+  async updateEntities(environmentUrl, updatedEntities, newVersionStamp) {
+    const existing = await this.load(environmentUrl);
+    const merged = existing?.entityTypeInfos ?? {};
+    for (const [name, info] of Object.entries(updatedEntities)) {
+      merged[name] = info;
+    }
+    await this.save(environmentUrl, merged, newVersionStamp);
+    log5.info(`Delta cache update: ${Object.keys(updatedEntities).length} entities updated`);
+  }
+  /**
+   * Remove specific entities from the cache (for deleted entities).
+   */
+  async removeEntities(environmentUrl, deletedEntityNames, newVersionStamp) {
+    const existing = await this.load(environmentUrl);
+    if (!existing) return;
+    const merged = existing.entityTypeInfos;
+    for (const name of deletedEntityNames) {
+      delete merged[name];
+    }
+    await this.save(environmentUrl, merged, newVersionStamp);
+    log5.info(`Removed ${deletedEntityNames.length} entities from cache`);
+  }
+  /**
+   * Delete the entire cache.
+   */
+  async clear() {
+    try {
+      await fs.unlink(this.cacheFilePath);
+      log5.info("Metadata cache cleared");
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Check if a cache file exists.
+   */
+  async exists() {
+    try {
+      await fs.access(this.cacheFilePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/metadata/labels.ts
+var DEFAULT_LABEL_CONFIG = {
+  primaryLanguage: 1033
+};
+function getPrimaryLabel(label, config) {
+  if (!label) return "";
+  return getLabelForLanguage(label, config.primaryLanguage);
+}
+function getJSDocLabel(label, config) {
+  if (!label) return "";
+  const primary = getLabelForLanguage(label, config.primaryLanguage);
+  if (!primary) return "";
+  if (!config.secondaryLanguage) return primary;
+  const secondary = getLabelForLanguage(label, config.secondaryLanguage);
+  if (!secondary || secondary === primary) return primary;
+  return `${primary} | ${secondary}`;
+}
+function getLabelForLanguage(label, languageCode) {
+  const localized = label.LocalizedLabels?.find(
+    (l) => l.LanguageCode === languageCode
+  );
+  if (localized?.Label) return localized.Label;
+  if (label.UserLocalizedLabel?.Label) return label.UserLocalizedLabel.Label;
+  return "";
+}
+var TRANSLITERATION_MAP = {
+  "\xE4": "ae",
+  "\xF6": "oe",
+  "\xFC": "ue",
+  "\xDF": "ss",
+  "\xC4": "Ae",
+  "\xD6": "Oe",
+  "\xDC": "Ue"
+};
+function transliterateUmlauts(text) {
+  return text.replace(/[äöüßÄÖÜ]/g, (char) => TRANSLITERATION_MAP[char] ?? char);
+}
+function labelToIdentifier(label) {
+  if (!label || label.trim().length === 0) return null;
+  const transliterated = transliterateUmlauts(label);
+  let cleaned = transliterated.replace(/[^a-zA-Z0-9\s_]/g, "");
+  cleaned = cleaned.trim();
+  if (cleaned.length === 0) return null;
+  const parts = cleaned.split(/[\s_]+/).filter((p) => p.length > 0);
+  const pascal = parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  if (pascal.length === 0) return null;
+  if (/^\d/.test(pascal)) {
+    return `_${pascal}`;
+  }
+  return pascal;
+}
+function generateEnumMembers(options, config) {
+  const members = options.map((option) => {
+    const primaryLabel = getPrimaryLabel(option.Label, config);
+    const identifier = labelToIdentifier(primaryLabel);
+    const jsDocLabel = getJSDocLabel(option.Label, config);
+    return {
+      rawName: identifier ?? `Value_${option.Value}`,
+      value: option.Value,
+      jsDocLabel: jsDocLabel || `Value ${option.Value}`,
+      fromLabel: identifier !== null
+    };
+  });
+  const nameCount = /* @__PURE__ */ new Map();
+  for (const m of members) {
+    nameCount.set(m.rawName, (nameCount.get(m.rawName) ?? 0) + 1);
+  }
+  const nameUsed = /* @__PURE__ */ new Map();
+  const result = [];
+  for (const m of members) {
+    const count = nameCount.get(m.rawName) ?? 1;
+    if (count === 1) {
+      result.push({ name: m.rawName, value: m.value, jsDocLabel: m.jsDocLabel });
+    } else {
+      if (!nameUsed.get(m.rawName)) {
+        nameUsed.set(m.rawName, true);
+        result.push({ name: m.rawName, value: m.value, jsDocLabel: m.jsDocLabel });
+      } else {
+        result.push({ name: `${m.rawName}_${m.value}`, value: m.value, jsDocLabel: m.jsDocLabel });
+      }
+    }
+  }
+  return result;
+}
+function getLabelLanguagesParam(config) {
+  const languages = [config.primaryLanguage];
+  if (config.secondaryLanguage && config.secondaryLanguage !== config.primaryLanguage) {
+    languages.push(config.secondaryLanguage);
+  }
+  return `&LabelLanguages=${languages.join(",")}`;
+}
+
+// src/generators/type-mapping.ts
+function getEntityPropertyType(attributeType, isLookup = false) {
+  if (isLookup) return "string";
+  const mapping = ENTITY_TYPE_MAP[attributeType];
+  if (mapping) return mapping;
+  return "unknown";
+}
+var ENTITY_TYPE_MAP = {
+  // String types
+  String: "string",
+  Memo: "string",
+  EntityName: "string",
+  // Numeric types
+  Integer: "number",
+  BigInt: "number",
+  Decimal: "number",
+  Double: "number",
+  Money: "number",
+  // Boolean
+  Boolean: "boolean",
+  // OptionSet types (numeric values in Web API)
+  Picklist: "number",
+  State: "number",
+  Status: "number",
+  // MultiSelectPicklist: Web API returns comma-separated string (e.g. "595300000,595300001")
+  // Verified live on markant-dev.crm4.dynamics.com 2026-03-29
+  MultiSelectPicklist: "string",
+  // Date/Time (ISO 8601 strings in Web API)
+  DateTime: "string",
+  // Identifiers
+  Uniqueidentifier: "string",
+  // Lookup (handled separately via _value pattern, but base type is string)
+  Lookup: "string",
+  Customer: "string",
+  Owner: "string",
+  PartyList: "string",
+  // Binary/Image (not typically in entity interfaces, filtered by shouldIncludeInEntityInterface)
+  Virtual: "unknown",
+  CalendarRules: "unknown"
+};
+function getFormAttributeType(attributeType) {
+  const mapping = FORM_ATTRIBUTE_TYPE_MAP[attributeType];
+  if (mapping) return mapping;
+  return "Xrm.Attributes.Attribute";
+}
+var FORM_ATTRIBUTE_TYPE_MAP = {
+  // String types
+  String: "Xrm.Attributes.StringAttribute",
+  Memo: "Xrm.Attributes.StringAttribute",
+  // Numeric types
+  Integer: "Xrm.Attributes.NumberAttribute",
+  BigInt: "Xrm.Attributes.NumberAttribute",
+  Decimal: "Xrm.Attributes.NumberAttribute",
+  Double: "Xrm.Attributes.NumberAttribute",
+  Money: "Xrm.Attributes.NumberAttribute",
+  // Boolean
+  Boolean: "Xrm.Attributes.BooleanAttribute",
+  // OptionSet types
+  Picklist: "Xrm.Attributes.OptionSetAttribute",
+  State: "Xrm.Attributes.OptionSetAttribute",
+  Status: "Xrm.Attributes.OptionSetAttribute",
+  MultiSelectPicklist: "Xrm.Attributes.MultiSelectOptionSetAttribute",
+  // Date/Time
+  DateTime: "Xrm.Attributes.DateAttribute",
+  // Lookup types
+  Lookup: "Xrm.Attributes.LookupAttribute",
+  Customer: "Xrm.Attributes.LookupAttribute",
+  Owner: "Xrm.Attributes.LookupAttribute",
+  PartyList: "Xrm.Attributes.LookupAttribute",
+  // Entity Name (string attribute in forms)
+  EntityName: "Xrm.Attributes.StringAttribute"
+};
+function getFormControlType(attributeType) {
+  const mapping = FORM_CONTROL_TYPE_MAP[attributeType];
+  if (mapping) return mapping;
+  return "Xrm.Controls.StandardControl";
+}
+var FORM_CONTROL_TYPE_MAP = {
+  // Standard controls
+  String: "Xrm.Controls.StringControl",
+  Memo: "Xrm.Controls.StringControl",
+  Integer: "Xrm.Controls.NumberControl",
+  BigInt: "Xrm.Controls.NumberControl",
+  Decimal: "Xrm.Controls.NumberControl",
+  Double: "Xrm.Controls.NumberControl",
+  Money: "Xrm.Controls.NumberControl",
+  Boolean: "Xrm.Controls.StandardControl",
+  DateTime: "Xrm.Controls.DateControl",
+  EntityName: "Xrm.Controls.StandardControl",
+  // OptionSet controls
+  Picklist: "Xrm.Controls.OptionSetControl",
+  State: "Xrm.Controls.OptionSetControl",
+  Status: "Xrm.Controls.OptionSetControl",
+  MultiSelectPicklist: "Xrm.Controls.MultiSelectOptionSetControl",
+  // Lookup controls
+  Lookup: "Xrm.Controls.LookupControl",
+  Customer: "Xrm.Controls.LookupControl",
+  Owner: "Xrm.Controls.LookupControl",
+  PartyList: "Xrm.Controls.LookupControl"
+};
+function toSafeIdentifier(logicalName) {
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(logicalName)) {
+    return logicalName;
+  }
+  let safe = logicalName.replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^\d/.test(safe)) {
+    safe = `_${safe}`;
+  }
+  if (safe.length === 0) {
+    return "_unnamed";
+  }
+  return safe;
+}
+function toPascalCase(logicalName) {
+  return logicalName.split("_").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function toLookupValueProperty(logicalName) {
+  return `_${logicalName}_value`;
+}
+function isLookupType(attributeType) {
+  return attributeType === "Lookup" || attributeType === "Customer" || attributeType === "Owner";
+}
+function isPartyListType(attributeType) {
+  return attributeType === "PartyList";
+}
+function shouldIncludeInEntityInterface(attr) {
+  if (attr.AttributeType === "Virtual" || attr.AttributeType === "CalendarRules") {
+    const odataType = attr["@odata.type"];
+    if (odataType !== "#Microsoft.Dynamics.CRM.MultiSelectPicklistAttributeMetadata") {
+      return false;
+    }
+  }
+  if (attr.AttributeType === "ManagedProperty") {
+    return false;
+  }
+  if (attr.AttributeType === "EntityName") {
+    return false;
+  }
+  if (attr.IsValidForRead === false) {
+    return false;
+  }
+  return true;
+}
+
+// src/generators/label-utils.ts
+function getSecondaryLabel(label, config) {
+  if (!config.secondaryLanguage) return void 0;
+  const secondary = label.LocalizedLabels.find((l) => l.LanguageCode === config.secondaryLanguage);
+  return secondary && secondary.Label || void 0;
+}
+function labelToEnumMember(labelText) {
+  if (!labelText) return "";
+  const transliterated = transliterateUmlauts(labelText);
+  const cleaned = transliterated.replace(/[^a-zA-Z0-9\s_]/g, "");
+  const parts = cleaned.split(/[\s_]+/).filter((p) => p.length > 0);
+  if (parts.length === 0) return "";
+  const pascal = parts.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+  if (/^\d/.test(pascal)) {
+    return `_${pascal}`;
+  }
+  return pascal;
+}
+function disambiguateEnumMembers(members) {
+  const allOriginalNames = new Set(members.map((m) => m.name));
+  const usedNames = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const { name, value } of members) {
+    let finalName = name;
+    if (usedNames.has(finalName)) {
+      finalName = `${name}_${value}`;
+      let attempt = 2;
+      while (usedNames.has(finalName) || allOriginalNames.has(finalName) && finalName !== name) {
+        finalName = `${name}_${value}_v${attempt}`;
+        attempt++;
+      }
+    }
+    usedNames.add(finalName);
+    result.push({ name: finalName, value });
+  }
+  return result;
+}
+
+// src/generators/entity-generator.ts
+function generateEntityInterface(info, options = {}) {
+  const labelConfig = options.labelConfig || DEFAULT_LABEL_CONFIG;
+  const namespace = options.namespace || "XrmForge.Entities";
+  const entityName = toPascalCase(info.entity.LogicalName);
+  const entityLabel = getJSDocLabel(info.entity.DisplayName, labelConfig);
+  const lines = [];
+  lines.push(`declare namespace ${namespace} {`);
+  lines.push("");
+  if (entityLabel) {
+    lines.push(`  /** ${entityLabel} */`);
+  }
+  lines.push(`  interface ${entityName} {`);
+  const includedAttrs = info.attributes.filter(shouldIncludeInEntityInterface).sort((a, b) => a.LogicalName.localeCompare(b.LogicalName));
+  const lookupTargets = /* @__PURE__ */ new Map();
+  for (const la of info.lookupAttributes) {
+    if (la.Targets && la.Targets.length > 0) {
+      lookupTargets.set(la.LogicalName, la.Targets);
+    }
+  }
+  for (const attr of includedAttrs) {
+    const isLookup = isLookupType(attr.AttributeType);
+    const propertyName = isLookup ? toLookupValueProperty(attr.LogicalName) : attr.LogicalName;
+    const tsType = getEntityPropertyType(attr.AttributeType, isLookup);
+    const label = getJSDocLabel(attr.DisplayName, labelConfig);
+    const jsdocParts = [];
+    if (label) jsdocParts.push(label);
+    if (isLookup) {
+      const targets = lookupTargets.get(attr.LogicalName);
+      if (targets && targets.length > 0) {
+        jsdocParts.push(`Lookup (${targets.join(" | ")})`);
+      }
+    }
+    if (!attr.IsValidForCreate && !attr.IsValidForUpdate && !attr.IsPrimaryId) {
+      jsdocParts.push("read-only");
+    }
+    if (jsdocParts.length > 0) {
+      lines.push(`    /** ${jsdocParts.join(" - ")} */`);
+    }
+    lines.push(`    ${propertyName}: ${tsType} | null;`);
+  }
+  const partyListAttrs = info.attributes.filter((a) => isPartyListType(a.AttributeType));
+  if (partyListAttrs.length > 0) {
+    const relationship = info.oneToManyRelationships.find(
+      (r) => r.ReferencingEntity === "activityparty"
+    );
+    const navPropName = relationship ? relationship.SchemaName.charAt(0).toLowerCase() + relationship.SchemaName.slice(1) : `${info.entity.LogicalName}_activity_parties`;
+    lines.push("");
+    lines.push(`    /** ActivityParty collection (${partyListAttrs.length} PartyList-Felder: ${partyListAttrs.map((a) => a.LogicalName).join(", ")}) */`);
+    lines.push(`    ${navPropName}: ActivityParty[] | null;`);
+  }
+  lines.push("  }");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/generators/optionset-generator.ts
+function generateOptionSetEnum(optionSet, _entityLogicalName, attributeSchemaName, options = {}) {
+  const labelConfig = options.labelConfig || DEFAULT_LABEL_CONFIG;
+  const namespace = options.namespace || "XrmForge.OptionSets";
+  const enumName = optionSet.IsGlobal ? toPascalCase(optionSet.Name) : toPascalCase(attributeSchemaName);
+  const rawMembers = optionSet.Options.map((opt) => {
+    const label = getPrimaryLabel(opt.Label, labelConfig);
+    const memberName = labelToEnumMember(label);
+    return {
+      name: memberName || `Value_${opt.Value}`,
+      // Fallback for empty/invalid labels
+      value: opt.Value,
+      option: opt
+    };
+  });
+  const disambiguated = disambiguateEnumMembers(
+    rawMembers.map((m) => ({ name: m.name, value: m.value }))
+  );
+  const lines = [];
+  lines.push(`declare namespace ${namespace} {`);
+  lines.push("");
+  const enumLabel = getJSDocLabel(optionSet.DisplayName, labelConfig);
+  if (enumLabel) {
+    lines.push(`  /** ${enumLabel} (${optionSet.Name}) */`);
+  }
+  lines.push(`  const enum ${enumName} {`);
+  for (let i = 0; i < disambiguated.length; i++) {
+    const member = disambiguated[i];
+    const rawMember = rawMembers[i];
+    if (!rawMember) continue;
+    const memberLabel = getJSDocLabel(rawMember.option.Label, labelConfig);
+    if (memberLabel) {
+      lines.push(`    /** ${memberLabel} */`);
+    }
+    lines.push(`    ${member.name} = ${member.value},`);
+  }
+  lines.push("  }");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateEntityOptionSets(picklistAttributes, entityLogicalName, options = {}) {
+  const results = [];
+  const generatedGlobals = /* @__PURE__ */ new Set();
+  for (const attr of picklistAttributes) {
+    const optionSet = attr.OptionSet || attr.GlobalOptionSet;
+    if (!optionSet || !optionSet.Options || optionSet.Options.length === 0) continue;
+    if (optionSet.IsGlobal && generatedGlobals.has(optionSet.Name)) continue;
+    if (optionSet.IsGlobal) generatedGlobals.add(optionSet.Name);
+    const enumName = optionSet.IsGlobal ? toPascalCase(optionSet.Name) : toPascalCase(attr.SchemaName);
+    const content = generateOptionSetEnum(optionSet, entityLogicalName, attr.SchemaName, options);
+    results.push({ enumName, content });
+  }
+  return results;
+}
+
+// src/generators/form-generator.ts
+function specialControlToXrmType(controlType) {
+  switch (controlType) {
+    case "subgrid":
+      return "Xrm.Controls.GridControl";
+    case "editablegrid":
+      return "Xrm.Controls.GridControl";
+    case "quickview":
+      return "Xrm.Controls.QuickFormControl";
+    case "webresource":
+      return "Xrm.Controls.IframeControl";
+    case "iframe":
+      return "Xrm.Controls.IframeControl";
+    case "notes":
+      return "Xrm.Controls.Control";
+    case "map":
+      return "Xrm.Controls.Control";
+    default:
+      return null;
+  }
+}
+function toSafeFormName(formName) {
+  const result = transliterateUmlauts(formName).replace(/[^a-zA-Z0-9\s]/g, "").split(/\s+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+  if (/^\d/.test(result)) return `_${result}`;
+  if (result.length === 0) return "_Unnamed";
+  return result;
+}
+function buildFormBaseName(entityPascal, safeFormName) {
+  if (safeFormName.startsWith(entityPascal)) {
+    return safeFormName;
+  }
+  return `${entityPascal}${safeFormName}`;
+}
+function labelToPascalMember(label) {
+  if (!label) return "";
+  const transliterated = transliterateUmlauts(label);
+  const cleaned = transliterated.replace(/[^a-zA-Z0-9\s_]/g, "");
+  const parts = cleaned.split(/[\s_]+/).filter((p) => p.length > 0);
+  if (parts.length === 0) return "";
+  const pascal = parts.map((p) => p.charAt(0).toUpperCase() + p.slice(1).toLowerCase()).join("");
+  if (/^\d/.test(pascal)) return `_${pascal}`;
+  return pascal;
+}
+function generateFormInterface(form, entityLogicalName, attributeMap, options = {}, baseNameOverride) {
+  const labelConfig = options.labelConfig || DEFAULT_LABEL_CONFIG;
+  const namespacePrefix = options.namespacePrefix || "XrmForge.Forms";
+  const entityPascal = toPascalCase(entityLogicalName);
+  const namespace = `${namespacePrefix}.${entityPascal}`;
+  const baseName = baseNameOverride || buildFormBaseName(entityPascal, toSafeFormName(form.name));
+  const interfaceName = `${baseName}Form`;
+  const fieldsTypeName = `${baseName}FormFields`;
+  const attrMapName = `${baseName}FormAttributeMap`;
+  const ctrlMapName = `${baseName}FormControlMap`;
+  const fieldNames = /* @__PURE__ */ new Set();
+  for (const control of form.allControls) {
+    if (control.datafieldname) {
+      fieldNames.add(control.datafieldname);
+    }
+  }
+  const fields = [];
+  const usedEnumNames = /* @__PURE__ */ new Set();
+  for (const fieldName of [...fieldNames].sort()) {
+    const attr = attributeMap.get(fieldName);
+    if (!attr) continue;
+    const primaryLabel = getPrimaryLabel(attr.DisplayName, labelConfig);
+    let enumMember = labelToPascalMember(primaryLabel);
+    if (!enumMember) {
+      enumMember = toPascalCase(fieldName);
+    }
+    const originalEnumMember = enumMember;
+    let counter = 2;
+    while (usedEnumNames.has(enumMember)) {
+      enumMember = `${originalEnumMember}${counter}`;
+      counter++;
+    }
+    usedEnumNames.add(enumMember);
+    const dualLabel = getJSDocLabel(attr.DisplayName, labelConfig);
+    fields.push({
+      logicalName: fieldName,
+      attributeType: attr.AttributeType,
+      formAttributeType: getFormAttributeType(attr.AttributeType),
+      formControlType: getFormControlType(attr.AttributeType),
+      label: dualLabel,
+      enumMemberName: enumMember
+    });
+  }
+  const lines = [];
+  lines.push(`declare namespace ${namespace} {`);
+  lines.push("");
+  lines.push(`  /** Valid field names for the "${form.name}" form */`);
+  lines.push(`  type ${fieldsTypeName} =`);
+  for (let i = 0; i < fields.length; i++) {
+    const separator = i === fields.length - 1 ? ";" : "";
+    lines.push(`    | "${fields[i].logicalName}"${separator}`);
+  }
+  lines.push("");
+  lines.push(`  /** Attribute type map for "${form.name}" */`);
+  lines.push(`  type ${attrMapName} = {`);
+  for (const field of fields) {
+    lines.push(`    ${field.logicalName}: ${field.formAttributeType};`);
+  }
+  lines.push("  };");
+  lines.push("");
+  lines.push(`  /** Control type map for "${form.name}" */`);
+  lines.push(`  type ${ctrlMapName} = {`);
+  for (const field of fields) {
+    lines.push(`    ${field.logicalName}: ${field.formControlType};`);
+  }
+  lines.push("  };");
+  lines.push("");
+  lines.push(`  /** Field constants for "${form.name}" (compile-time only, zero runtime) */`);
+  lines.push(`  const enum ${fieldsTypeName}Enum {`);
+  for (const field of fields) {
+    if (field.label) {
+      lines.push(`    /** ${field.label} */`);
+    }
+    lines.push(`    ${field.enumMemberName} = '${field.logicalName}',`);
+  }
+  lines.push("  }");
+  lines.push("");
+  const namedTabs = form.tabs.filter((t) => t.name);
+  if (namedTabs.length > 0) {
+    const tabsEnumName = `${baseName}FormTabs`;
+    const usedTabMembers = /* @__PURE__ */ new Set();
+    const tabMemberNames = [];
+    for (const tab of namedTabs) {
+      let memberName = toSafeFormName(tab.name) || toPascalCase(tab.name);
+      const originalName = memberName;
+      let counter = 2;
+      while (usedTabMembers.has(memberName)) {
+        memberName = `${originalName}${counter}`;
+        counter++;
+      }
+      usedTabMembers.add(memberName);
+      tabMemberNames.push(memberName);
+    }
+    lines.push(`  /** Tab constants for "${form.name}" (compile-time only, zero runtime) */`);
+    lines.push(`  const enum ${tabsEnumName} {`);
+    for (let i = 0; i < namedTabs.length; i++) {
+      const tab = namedTabs[i];
+      if (tab.label) {
+        lines.push(`    /** ${tab.label} */`);
+      }
+      lines.push(`    ${tabMemberNames[i]} = '${tab.name}',`);
+    }
+    lines.push("  }");
+    lines.push("");
+    for (let i = 0; i < namedTabs.length; i++) {
+      const tab = namedTabs[i];
+      const namedSections = tab.sections.filter((s) => s.name);
+      if (namedSections.length === 0) continue;
+      const tabMemberName = tabMemberNames[i];
+      const sectionsEnumName = `${baseName}Form${tabMemberName}Sections`;
+      lines.push(`  /** Section constants for tab "${tab.name}" (compile-time only, zero runtime) */`);
+      lines.push(`  const enum ${sectionsEnumName} {`);
+      const usedSectionMembers = /* @__PURE__ */ new Set();
+      for (const section of namedSections) {
+        if (section.label) {
+          lines.push(`    /** ${section.label} */`);
+        }
+        let sectionMember = toSafeFormName(section.name) || toPascalCase(section.name);
+        const originalSectionMember = sectionMember;
+        let sCounter = 2;
+        while (usedSectionMembers.has(sectionMember)) {
+          sectionMember = `${originalSectionMember}${sCounter}`;
+          sCounter++;
+        }
+        usedSectionMembers.add(sectionMember);
+        lines.push(`    ${sectionMember} = '${section.name}',`);
+      }
+      lines.push("  }");
+      lines.push("");
+    }
+  }
+  lines.push(`  /** ${form.name} */`);
+  lines.push(`  interface ${interfaceName} extends Omit<Xrm.FormContext, 'getAttribute' | 'getControl'> {`);
+  lines.push(`    /** Typisierter Feldzugriff: nur Felder die auf diesem Formular existieren */`);
+  lines.push(`    getAttribute<K extends ${fieldsTypeName}>(name: K): ${attrMapName}[K];`);
+  lines.push("    getAttribute(index: number): Xrm.Attributes.Attribute;");
+  lines.push("    getAttribute(): Xrm.Attributes.Attribute[];");
+  lines.push("");
+  lines.push(`    /** Typisierter Control-Zugriff: nur Controls die auf diesem Formular existieren */`);
+  lines.push(`    getControl<K extends ${fieldsTypeName}>(name: K): ${ctrlMapName}[K];`);
+  const specialControls = form.allSpecialControls || [];
+  for (const sc of specialControls) {
+    const xrmType = specialControlToXrmType(sc.controlType);
+    if (xrmType) {
+      lines.push(`    getControl(name: "${sc.id}"): ${xrmType};`);
+    }
+  }
+  lines.push("    getControl(index: number): Xrm.Controls.Control;");
+  lines.push("    getControl(): Xrm.Controls.Control[];");
+  if (form.tabs.length > 0) {
+    lines.push("");
+    lines.push("    /** Typisierter Tab-Zugriff */");
+    lines.push("    ui: {");
+    lines.push("      tabs: {");
+    for (const tab of form.tabs) {
+      if (tab.name) {
+        const sectionNames = tab.sections.filter((s) => s.name).map((s) => s.name);
+        if (sectionNames.length > 0) {
+          lines.push(`        get(name: "${tab.name}"): Xrm.Controls.Tab & {`);
+          lines.push("          sections: {");
+          for (const sectionName of sectionNames) {
+            lines.push(`            get(name: "${sectionName}"): Xrm.Controls.Section;`);
+          }
+          lines.push("            get(name: string): Xrm.Controls.Section;");
+          lines.push("          };");
+          lines.push("        };");
+        } else {
+          lines.push(`        get(name: "${tab.name}"): Xrm.Controls.Tab;`);
+        }
+      }
+    }
+    lines.push("        get(name: string): Xrm.Controls.Tab;");
+    lines.push("      };");
+    lines.push("    } & Xrm.Ui;");
+  }
+  lines.push("  }");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateEntityForms(forms, entityLogicalName, attributes, options = {}) {
+  const attributeMap = /* @__PURE__ */ new Map();
+  for (const attr of attributes) {
+    attributeMap.set(attr.LogicalName, attr);
+  }
+  const entityPascal = toPascalCase(entityLogicalName);
+  const validForms = forms.filter((f) => f.allControls.length > 0);
+  const baseNames = validForms.map((form) => {
+    const safeFormName = toSafeFormName(form.name);
+    return buildFormBaseName(entityPascal, safeFormName);
+  });
+  const baseNameCounts = /* @__PURE__ */ new Map();
+  for (const name of baseNames) {
+    baseNameCounts.set(name, (baseNameCounts.get(name) || 0) + 1);
+  }
+  const baseNameCounters = /* @__PURE__ */ new Map();
+  const results = [];
+  for (let i = 0; i < validForms.length; i++) {
+    const form = validForms[i];
+    let baseName = baseNames[i];
+    if (baseNameCounts.get(baseName) > 1) {
+      const counter = (baseNameCounters.get(baseName) || 0) + 1;
+      baseNameCounters.set(baseName, counter);
+      if (counter > 1) {
+        baseName = `${baseName}${counter}`;
+      }
+    }
+    const interfaceName = `${baseName}Form`;
+    const content = generateFormInterface(form, entityLogicalName, attributeMap, options, baseName);
+    results.push({ formName: form.name, interfaceName, content });
+  }
+  return results;
+}
+
+// src/orchestrator/file-writer.ts
+import { mkdir, writeFile, readFile } from "fs/promises";
+import { join as join2, dirname } from "path";
+async function writeGeneratedFile(outputDir, file) {
+  const absolutePath = join2(outputDir, file.relativePath);
+  try {
+    const existing = await readFile(absolutePath, "utf-8");
+    if (existing === file.content) {
+      return false;
+    }
+  } catch {
+  }
+  await mkdir(dirname(absolutePath), { recursive: true });
+  await writeFile(absolutePath, file.content, "utf-8");
+  return true;
+}
+async function writeAllFiles(outputDir, files) {
+  const result = { written: 0, unchanged: 0, warnings: [] };
+  for (const file of files) {
+    try {
+      const changed = await writeGeneratedFile(outputDir, file);
+      if (changed) {
+        result.written++;
+      } else {
+        result.unchanged++;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      result.warnings.push(`Konnte ${file.relativePath} nicht schreiben: ${message}`);
+    }
+  }
+  return result;
+}
+var GENERATED_HEADER = `// \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+// This file was generated by @xrmforge/typegen. Do not edit manually.
+// Re-run 'xrmforge generate' to update.
+// \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+`;
+function addGeneratedHeader(content) {
+  return GENERATED_HEADER + content;
+}
+function generateBarrelIndex(files) {
+  const lines = [GENERATED_HEADER];
+  const entities = files.filter((f) => f.type === "entity");
+  const optionsets = files.filter((f) => f.type === "optionset");
+  const forms = files.filter((f) => f.type === "form");
+  if (entities.length > 0) {
+    lines.push("// Entity Interfaces");
+    for (const f of entities) {
+      lines.push(`/// <reference path="${f.relativePath}" />`);
+    }
+    lines.push("");
+  }
+  if (optionsets.length > 0) {
+    lines.push("// OptionSet Enums");
+    for (const f of optionsets) {
+      lines.push(`/// <reference path="${f.relativePath}" />`);
+    }
+    lines.push("");
+  }
+  if (forms.length > 0) {
+    lines.push("// Form Interfaces");
+    for (const f of forms) {
+      lines.push(`/// <reference path="${f.relativePath}" />`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/orchestrator/orchestrator.ts
+var TypeGenerationOrchestrator = class {
+  config;
+  credential;
+  logger;
+  constructor(credential, config, logger) {
+    this.credential = credential;
+    this.logger = logger ?? createLogger("orchestrator");
+    if (config.useCache) {
+      throw new Error(
+        "Metadata caching is not yet implemented (planned for v0.2.0). Remove the useCache option or set it to false."
+      );
+    }
+    this.config = {
+      environmentUrl: config.environmentUrl,
+      entities: [...config.entities],
+      solutionNames: config.solutionNames ?? [],
+      outputDir: config.outputDir,
+      labelConfig: config.labelConfig,
+      generateEntities: config.generateEntities ?? true,
+      generateForms: config.generateForms ?? true,
+      generateOptionSets: config.generateOptionSets ?? true,
+      useCache: config.useCache ?? false,
+      cacheDir: config.cacheDir ?? ".xrmforge/cache",
+      namespacePrefix: config.namespacePrefix ?? "XrmForge"
+    };
+  }
+  /**
+   * Run the full type generation pipeline.
+   *
+   * @param options - Optional parameters
+   * @param options.signal - AbortSignal to cancel the generation process.
+   *   When aborted, entities that have not yet started processing are skipped.
+   *   Entities already in progress may still complete or fail with an abort error.
+   */
+  async generate(options) {
+    const signal = options?.signal;
+    const startTime = Date.now();
+    const allFiles = [];
+    const entityResults = [];
+    if (signal?.aborted) {
+      return { entities: [], totalFiles: 0, totalWarnings: 0, durationMs: 0 };
+    }
+    this.logger.info("Starting type generation", {
+      entities: this.config.entities,
+      outputDir: this.config.outputDir
+    });
+    const httpClient = new DataverseHttpClient({
+      environmentUrl: this.config.environmentUrl,
+      credential: this.credential
+    });
+    const metadataClient = new MetadataClient(httpClient);
+    if (this.config.solutionNames && this.config.solutionNames.length > 0) {
+      this.logger.info(`Resolving entities from ${this.config.solutionNames.length} solution(s): ${this.config.solutionNames.join(", ")}`);
+      const solutionEntityNames = await metadataClient.getEntityNamesForSolutions(this.config.solutionNames);
+      this.logger.info(`Found ${solutionEntityNames.length} entities in solution(s)`);
+      const merged = /* @__PURE__ */ new Set([...this.config.entities, ...solutionEntityNames]);
+      this.config.entities = [...merged].sort();
+    }
+    if (this.config.entities.length === 0) {
+      this.logger.warn("No entities to process. Check --entities or --solutions.");
+      return {
+        entities: [],
+        totalFiles: 0,
+        totalWarnings: 1,
+        durationMs: Date.now() - startTime
+      };
+    }
+    this.logger.info(`Processing ${this.config.entities.length} entities in parallel`);
+    const settled = await Promise.allSettled(
+      this.config.entities.map((entityName) => {
+        if (signal?.aborted) {
+          return Promise.reject(new Error("Generation aborted"));
+        }
+        return this.processEntity(entityName, metadataClient).then((result) => {
+          this.logger.info(`Completed entity: ${entityName} (${result.files.length} files)`);
+          return result;
+        });
+      })
+    );
+    for (let i = 0; i < settled.length; i++) {
+      const outcome = settled[i];
+      const entityName = this.config.entities[i];
+      if (outcome.status === "fulfilled") {
+        entityResults.push(outcome.value);
+        allFiles.push(...outcome.value.files);
+      } else {
+        const errorMsg = outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason);
+        this.logger.error(`Failed to process entity: ${entityName}`, { error: outcome.reason });
+        entityResults.push({
+          entityLogicalName: entityName,
+          files: [],
+          warnings: [`Failed to process: ${errorMsg}`]
+        });
+      }
+    }
+    if (allFiles.length > 0) {
+      const indexContent = generateBarrelIndex(allFiles);
+      const indexFile = {
+        relativePath: "index.d.ts",
+        content: indexContent,
+        type: "entity"
+      };
+      allFiles.push(indexFile);
+    }
+    const writeResult = await writeAllFiles(this.config.outputDir, allFiles);
+    const durationMs = Date.now() - startTime;
+    const entityWarnings = entityResults.reduce((sum, r) => sum + r.warnings.length, 0);
+    const totalWarnings = entityWarnings + writeResult.warnings.length;
+    for (const w of writeResult.warnings) {
+      this.logger.warn(w);
+    }
+    this.logger.info("Type generation complete", {
+      entities: entityResults.length,
+      filesWritten: writeResult.written,
+      filesUnchanged: writeResult.unchanged,
+      totalFiles: allFiles.length,
+      totalWarnings,
+      durationMs
+    });
+    return {
+      entities: entityResults,
+      totalFiles: allFiles.length,
+      totalWarnings,
+      durationMs
+    };
+  }
+  /**
+   * Process a single entity: fetch metadata, generate all output files.
+   */
+  async processEntity(entityName, metadataClient) {
+    const warnings = [];
+    const files = [];
+    const entityInfo = await metadataClient.getEntityTypeInfo(entityName);
+    if (this.config.generateEntities) {
+      const entityContent = generateEntityInterface(entityInfo, {
+        labelConfig: this.config.labelConfig,
+        namespace: `${this.config.namespacePrefix}.Entities`
+      });
+      files.push({
+        relativePath: `entities/${entityName}.d.ts`,
+        content: addGeneratedHeader(entityContent),
+        type: "entity"
+      });
+    }
+    if (this.config.generateOptionSets) {
+      const picklistAttrs = this.getPicklistAttributes(entityInfo);
+      if (picklistAttrs.length > 0) {
+        const optionSets = generateEntityOptionSets(picklistAttrs, entityName, {
+          labelConfig: this.config.labelConfig,
+          namespace: `${this.config.namespacePrefix}.OptionSets`
+        });
+        if (optionSets.length > 0) {
+          const combinedContent = optionSets.map((os) => os.content).join("\n");
+          files.push({
+            relativePath: `optionsets/${entityName}.d.ts`,
+            content: addGeneratedHeader(combinedContent),
+            type: "optionset"
+          });
+        }
+      } else {
+        warnings.push(`No OptionSet attributes found for ${entityName}`);
+      }
+    }
+    if (this.config.generateForms) {
+      if (entityInfo.forms.length > 0) {
+        const formResults = generateEntityForms(
+          entityInfo.forms,
+          entityName,
+          entityInfo.attributes,
+          {
+            labelConfig: this.config.labelConfig,
+            namespacePrefix: `${this.config.namespacePrefix}.Forms`
+          }
+        );
+        if (formResults.length > 0) {
+          const combinedContent = formResults.map((f) => f.content).join("\n");
+          files.push({
+            relativePath: `forms/${entityName}.d.ts`,
+            content: addGeneratedHeader(combinedContent),
+            type: "form"
+          });
+        }
+      } else {
+        warnings.push(`No forms found for ${entityName}`);
+      }
+    }
+    return { entityLogicalName: entityName, files, warnings };
+  }
+  /**
+   * Extract picklist attributes with their OptionSet metadata.
+   * Maps the raw EntityTypeInfo data to the format expected by the OptionSet generator.
+   */
+  getPicklistAttributes(entityInfo) {
+    const result = [];
+    for (const attr of entityInfo.picklistAttributes) {
+      result.push({
+        SchemaName: attr.SchemaName,
+        OptionSet: attr.OptionSet ?? null,
+        GlobalOptionSet: attr.GlobalOptionSet ?? null
+      });
+    }
+    for (const attr of entityInfo.stateAttributes) {
+      result.push({
+        SchemaName: attr.SchemaName,
+        OptionSet: attr.OptionSet ?? null,
+        GlobalOptionSet: null
+      });
+    }
+    for (const attr of entityInfo.statusAttributes) {
+      result.push({
+        SchemaName: attr.SchemaName,
+        OptionSet: attr.OptionSet ?? null,
+        GlobalOptionSet: null
+      });
+    }
+    return result;
+  }
+};
+export {
+  ApiRequestError,
+  AuthenticationError,
+  ConfigError,
+  ConsoleLogSink,
+  DEFAULT_LABEL_CONFIG,
+  DataverseHttpClient,
+  ErrorCode,
+  FastXmlParser,
+  GenerationError,
+  JsonLogSink,
+  LogLevel,
+  Logger,
+  MetadataCache,
+  MetadataClient,
+  MetadataError,
+  SilentLogSink,
+  TypeGenerationOrchestrator,
+  XrmForgeError,
+  configureLogging,
+  createCredential,
+  createLogger,
+  defaultXmlParser,
+  disambiguateEnumMembers,
+  extractControlFields,
+  getJSDocLabel as formatDualLabel,
+  generateEntityForms,
+  generateEntityInterface,
+  generateEntityOptionSets,
+  generateEnumMembers,
+  generateFormInterface,
+  generateOptionSetEnum,
+  getEntityPropertyType,
+  getFormAttributeType,
+  getFormControlType,
+  getJSDocLabel,
+  getLabelLanguagesParam,
+  getPrimaryLabel,
+  getSecondaryLabel,
+  isLookupType,
+  isRateLimitError,
+  isXrmForgeError,
+  labelToIdentifier,
+  parseForm,
+  shouldIncludeInEntityInterface,
+  toLookupValueProperty,
+  toPascalCase,
+  toSafeIdentifier
+};
+//# sourceMappingURL=index.js.map