@uipath/packager-tool-datafabric 1.204.0 → 1.205.0-preview.258

package/dist/inline.js

@@ -0,0 +1,3665 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../../../node_modules/is-inside-container/node_modules/is-docker/index.js
+import fs from "node:fs";
+function hasDockerEnv() {
+  try {
+    fs.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === undefined) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+var isDockerCached;
+var init_is_docker = () => {};
+
+// ../../../node_modules/is-inside-container/index.js
+import fs2 from "node:fs";
+function isInsideContainer() {
+  if (cachedResult === undefined) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+var cachedResult, hasContainerEnv = () => {
+  try {
+    fs2.statSync("/run/.containerenv");
+    return true;
+  } catch {
+    return false;
+  }
+};
+var init_is_inside_container = __esm(() => {
+  init_is_docker();
+});
+
+// ../../../node_modules/wsl-utils/node_modules/is-wsl/index.js
+import process2 from "node:process";
+import os from "node:os";
+import fs3 from "node:fs";
+var isWsl = () => {
+  if (process2.platform !== "linux") {
+    return false;
+  }
+  if (os.release().toLowerCase().includes("microsoft")) {
+    if (isInsideContainer()) {
+      return false;
+    }
+    return true;
+  }
+  try {
+    if (fs3.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
+      return !isInsideContainer();
+    }
+  } catch {}
+  if (fs3.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs3.existsSync("/run/WSL")) {
+    return !isInsideContainer();
+  }
+  return false;
+}, is_wsl_default;
+var init_is_wsl = __esm(() => {
+  init_is_inside_container();
+  is_wsl_default = process2.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+});
+
+// ../../../node_modules/powershell-utils/index.js
+import process3 from "node:process";
+import { Buffer } from "node:buffer";
+import { promisify } from "node:util";
+import childProcess from "node:child_process";
+var execFile, powerShellPath = () => `${process3.env.SYSTEMROOT || process3.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`, executePowerShell = async (command, options = {}) => {
+  const {
+    powerShellPath: psPath,
+    ...execFileOptions
+  } = options;
+  const encodedCommand = executePowerShell.encodeCommand(command);
+  return execFile(psPath ?? powerShellPath(), [
+    ...executePowerShell.argumentsPrefix,
+    encodedCommand
+  ], {
+    encoding: "utf8",
+    ...execFileOptions
+  });
+};
+var init_powershell_utils = __esm(() => {
+  execFile = promisify(childProcess.execFile);
+  executePowerShell.argumentsPrefix = [
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-EncodedCommand"
+  ];
+  executePowerShell.encodeCommand = (command) => Buffer.from(command, "utf16le").toString("base64");
+  executePowerShell.escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`;
+});
+
+// ../../../node_modules/wsl-utils/utilities.js
+function parseMountPointFromConfig(content) {
+  for (const line of content.split(`
+`)) {
+    if (/^\s*#/.test(line)) {
+      continue;
+    }
+    const match = /^\s*root\s*=\s*(?<mountPoint>"[^"]*"|'[^']*'|[^#]*)/.exec(line);
+    if (!match) {
+      continue;
+    }
+    return match.groups.mountPoint.trim().replaceAll(/^["']|["']$/g, "");
+  }
+}
+
+// ../../../node_modules/wsl-utils/index.js
+import { promisify as promisify2 } from "node:util";
+import childProcess2 from "node:child_process";
+import fs4, { constants as fsConstants } from "node:fs/promises";
+var execFile2, wslDrivesMountPoint, powerShellPathFromWsl = async () => {
+  const mountPoint = await wslDrivesMountPoint();
+  return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+}, powerShellPath2, canAccessPowerShellPromise, canAccessPowerShell = async () => {
+  canAccessPowerShellPromise ??= (async () => {
+    try {
+      const psPath = await powerShellPath2();
+      await fs4.access(psPath, fsConstants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  return canAccessPowerShellPromise;
+}, wslDefaultBrowser = async () => {
+  const psPath = await powerShellPath2();
+  const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+  const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
+  return stdout.trim();
+}, convertWslPathToWindows = async (path) => {
+  if (/^[a-z]+:\/\//i.test(path)) {
+    return path;
+  }
+  try {
+    const { stdout } = await execFile2("wslpath", ["-aw", path], { encoding: "utf8" });
+    return stdout.trim();
+  } catch {
+    return path;
+  }
+};
+var init_wsl_utils = __esm(() => {
+  init_is_wsl();
+  init_powershell_utils();
+  init_is_wsl();
+  execFile2 = promisify2(childProcess2.execFile);
+  wslDrivesMountPoint = (() => {
+    const defaultMountPoint = "/mnt/";
+    let mountPoint;
+    return async function() {
+      if (mountPoint) {
+        return mountPoint;
+      }
+      const configFilePath = "/etc/wsl.conf";
+      let isConfigFileExists = false;
+      try {
+        await fs4.access(configFilePath, fsConstants.F_OK);
+        isConfigFileExists = true;
+      } catch {}
+      if (!isConfigFileExists) {
+        return defaultMountPoint;
+      }
+      const configContent = await fs4.readFile(configFilePath, { encoding: "utf8" });
+      const parsedMountPoint = parseMountPointFromConfig(configContent);
+      if (parsedMountPoint === undefined) {
+        return defaultMountPoint;
+      }
+      mountPoint = parsedMountPoint;
+      mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+      return mountPoint;
+    };
+  })();
+  powerShellPath2 = is_wsl_default ? powerShellPathFromWsl : powerShellPath;
+});
+
+// ../../../node_modules/open/node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+  const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+  Object.defineProperty(object, propertyName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const result = valueGetter();
+      define(result);
+      return result;
+    },
+    set(value) {
+      define(value);
+    }
+  });
+  return object;
+}
+
+// ../../../node_modules/default-browser-id/index.js
+import { promisify as promisify3 } from "node:util";
+import process4 from "node:process";
+import { execFile as execFile3 } from "node:child_process";
+async function defaultBrowserId() {
+  if (process4.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+  const browserId = match?.groups.id ?? "com.apple.Safari";
+  if (browserId === "com.apple.safari") {
+    return "com.apple.Safari";
+  }
+  return browserId;
+}
+var execFileAsync;
+var init_default_browser_id = __esm(() => {
+  execFileAsync = promisify3(execFile3);
+});
+
+// ../../../node_modules/run-applescript/index.js
+import process5 from "node:process";
+import { promisify as promisify4 } from "node:util";
+import { execFile as execFile4, execFileSync } from "node:child_process";
+async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+  if (process5.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const outputArguments = humanReadableOutput ? [] : ["-ss"];
+  const execOptions = {};
+  if (signal) {
+    execOptions.signal = signal;
+  }
+  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments], execOptions);
+  return stdout.trim();
+}
+var execFileAsync2;
+var init_run_applescript = __esm(() => {
+  execFileAsync2 = promisify4(execFile4);
+});
+
+// ../../../node_modules/bundle-name/index.js
+async function bundleName(bundleId) {
+  return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
+tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+var init_bundle_name = __esm(() => {
+  init_run_applescript();
+});
+
+// ../../../node_modules/default-browser/windows.js
+import { promisify as promisify5 } from "node:util";
+import { execFile as execFile5 } from "node:child_process";
+async function defaultBrowser(_execFileAsync = execFileAsync3) {
+  const { stdout } = await _execFileAsync("reg", [
+    "QUERY",
+    " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+    "/v",
+    "ProgId"
+  ]);
+  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+  if (!match) {
+    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+  }
+  const { id } = match.groups;
+  const dotIndex = id.lastIndexOf(".");
+  const hyphenIndex = id.lastIndexOf("-");
+  const baseIdByDot = dotIndex === -1 ? undefined : id.slice(0, dotIndex);
+  const baseIdByHyphen = hyphenIndex === -1 ? undefined : id.slice(0, hyphenIndex);
+  return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? { name: id, id };
+}
+var execFileAsync3, windowsBrowserProgIds, _windowsBrowserProgIdMap, UnknownBrowserError;
+var init_windows = __esm(() => {
+  execFileAsync3 = promisify5(execFile5);
+  windowsBrowserProgIds = {
+    MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
+    MSEdgeBHTML: { name: "Edge Beta", id: "com.microsoft.edge.beta" },
+    MSEdgeDHTML: { name: "Edge Dev", id: "com.microsoft.edge.dev" },
+    AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
+    ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
+    ChromeBHTML: { name: "Chrome Beta", id: "com.google.chrome.beta" },
+    ChromeDHTML: { name: "Chrome Dev", id: "com.google.chrome.dev" },
+    ChromiumHTM: { name: "Chromium", id: "org.chromium.Chromium" },
+    BraveHTML: { name: "Brave", id: "com.brave.Browser" },
+    BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
+    BraveDHTML: { name: "Brave Dev", id: "com.brave.Browser.dev" },
+    BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" },
+    FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+    OperaStable: { name: "Opera", id: "com.operasoftware.Opera" },
+    VivaldiHTM: { name: "Vivaldi", id: "com.vivaldi.Vivaldi" },
+    "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" }
+  };
+  _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+  UnknownBrowserError = class UnknownBrowserError extends Error {
+  };
+});
+
+// ../../../node_modules/default-browser/index.js
+import { promisify as promisify6 } from "node:util";
+import process6 from "node:process";
+import { execFile as execFile6 } from "node:child_process";
+async function defaultBrowser2() {
+  if (process6.platform === "darwin") {
+    const id = await defaultBrowserId();
+    const name = await bundleName(id);
+    return { name, id };
+  }
+  if (process6.platform === "linux") {
+    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const id = stdout.trim();
+    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
+    return { name, id };
+  }
+  if (process6.platform === "win32") {
+    return defaultBrowser();
+  }
+  throw new Error("Only macOS, Linux, and Windows are supported");
+}
+var execFileAsync4, titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+var init_default_browser = __esm(() => {
+  init_default_browser_id();
+  init_bundle_name();
+  init_windows();
+  init_windows();
+  execFileAsync4 = promisify6(execFile6);
+});
+
+// ../../../node_modules/is-in-ssh/index.js
+import process7 from "node:process";
+var isInSsh, is_in_ssh_default;
+var init_is_in_ssh = __esm(() => {
+  isInSsh = Boolean(process7.env.SSH_CONNECTION || process7.env.SSH_CLIENT || process7.env.SSH_TTY);
+  is_in_ssh_default = isInSsh;
+});
+
+// ../../../node_modules/open/index.js
+var exports_open = {};
+__export(exports_open, {
+  apps: () => apps,
+  default: () => open_default,
+  openApp: () => openApp
+});
+import process8 from "node:process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import childProcess3 from "node:child_process";
+import fs5, { constants as fsConstants2 } from "node:fs/promises";
+function detectArchBinary(binary) {
+  if (typeof binary === "string" || Array.isArray(binary)) {
+    return binary;
+  }
+  const { [arch]: archBinary } = binary;
+  if (!archBinary) {
+    throw new Error(`${arch} is not supported`);
+  }
+  return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl } = {}) {
+  if (wsl && is_wsl_default) {
+    return detectArchBinary(wsl);
+  }
+  if (!platformBinary) {
+    throw new Error(`${platform} is not supported`);
+  }
+  return detectArchBinary(platformBinary);
+}
+var fallbackAttemptSymbol, __dirname2, localXdgOpenPath, platform, arch, tryEachApp = async (apps, opener) => {
+  if (apps.length === 0) {
+    return;
+  }
+  const errors = [];
+  for (const app of apps) {
+    try {
+      return await opener(app);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  throw new AggregateError(errors, "Failed to open in all supported apps");
+}, baseOpen = async (options) => {
+  options = {
+    wait: false,
+    background: false,
+    newInstance: false,
+    allowNonzeroExitCode: false,
+    ...options
+  };
+  const isFallbackAttempt = options[fallbackAttemptSymbol] === true;
+  delete options[fallbackAttemptSymbol];
+  if (Array.isArray(options.app)) {
+    return tryEachApp(options.app, (singleApp) => baseOpen({
+      ...options,
+      app: singleApp,
+      [fallbackAttemptSymbol]: true
+    }));
+  }
+  let { name: app, arguments: appArguments = [] } = options.app ?? {};
+  appArguments = [...appArguments];
+  if (Array.isArray(app)) {
+    return tryEachApp(app, (appName) => baseOpen({
+      ...options,
+      app: {
+        name: appName,
+        arguments: appArguments
+      },
+      [fallbackAttemptSymbol]: true
+    }));
+  }
+  if (app === "browser" || app === "browserPrivate") {
+    const ids = {
+      "com.google.chrome": "chrome",
+      "google-chrome.desktop": "chrome",
+      "com.brave.browser": "brave",
+      "org.mozilla.firefox": "firefox",
+      "firefox.desktop": "firefox",
+      "com.microsoft.msedge": "edge",
+      "com.microsoft.edge": "edge",
+      "com.microsoft.edgemac": "edge",
+      "microsoft-edge.desktop": "edge",
+      "com.apple.safari": "safari"
+    };
+    const flags = {
+      chrome: "--incognito",
+      brave: "--incognito",
+      firefox: "--private-window",
+      edge: "--inPrivate"
+    };
+    let browser;
+    if (is_wsl_default) {
+      const progId = await wslDefaultBrowser();
+      const browserInfo = _windowsBrowserProgIdMap.get(progId);
+      browser = browserInfo ?? {};
+    } else {
+      browser = await defaultBrowser2();
+    }
+    if (browser.id in ids) {
+      const browserName = ids[browser.id.toLowerCase()];
+      if (app === "browserPrivate") {
+        if (browserName === "safari") {
+          throw new Error("Safari doesn't support opening in private mode via command line");
+        }
+        appArguments.push(flags[browserName]);
+      }
+      return baseOpen({
+        ...options,
+        app: {
+          name: apps[browserName],
+          arguments: appArguments
+        }
+      });
+    }
+    throw new Error(`${browser.name} is not supported as a default browser`);
+  }
+  let command;
+  const cliArguments = [];
+  const childProcessOptions = {};
+  let shouldUseWindowsInWsl = false;
+  if (is_wsl_default && !isInsideContainer() && !is_in_ssh_default && !app) {
+    shouldUseWindowsInWsl = await canAccessPowerShell();
+  }
+  if (platform === "darwin") {
+    command = "open";
+    if (options.wait) {
+      cliArguments.push("--wait-apps");
+    }
+    if (options.background) {
+      cliArguments.push("--background");
+    }
+    if (options.newInstance) {
+      cliArguments.push("--new");
+    }
+    if (app) {
+      cliArguments.push("-a", app);
+    }
+  } else if (platform === "win32" || shouldUseWindowsInWsl) {
+    command = await powerShellPath2();
+    cliArguments.push(...executePowerShell.argumentsPrefix);
+    if (!is_wsl_default) {
+      childProcessOptions.windowsVerbatimArguments = true;
+    }
+    if (is_wsl_default && options.target) {
+      options.target = await convertWslPathToWindows(options.target);
+    }
+    const encodedArguments = ["$ProgressPreference = 'SilentlyContinue';", "Start"];
+    if (options.wait) {
+      encodedArguments.push("-Wait");
+    }
+    if (app) {
+      encodedArguments.push(executePowerShell.escapeArgument(app));
+      if (options.target) {
+        appArguments.push(options.target);
+      }
+    } else if (options.target) {
+      encodedArguments.push(executePowerShell.escapeArgument(options.target));
+    }
+    if (appArguments.length > 0) {
+      appArguments = appArguments.map((argument) => executePowerShell.escapeArgument(argument));
+      encodedArguments.push("-ArgumentList", appArguments.join(","));
+    }
+    options.target = executePowerShell.encodeCommand(encodedArguments.join(" "));
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+    }
+  } else {
+    if (app) {
+      command = app;
+    } else {
+      const isBundled = !__dirname2 || __dirname2 === "/";
+      let exeLocalXdgOpen = false;
+      try {
+        await fs5.access(localXdgOpenPath, fsConstants2.X_OK);
+        exeLocalXdgOpen = true;
+      } catch {}
+      const useSystemXdgOpen = process8.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
+      command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+    }
+    if (appArguments.length > 0) {
+      cliArguments.push(...appArguments);
+    }
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+      childProcessOptions.detached = true;
+    }
+  }
+  if (platform === "darwin" && appArguments.length > 0) {
+    cliArguments.push("--args", ...appArguments);
+  }
+  if (options.target) {
+    cliArguments.push(options.target);
+  }
+  const subprocess = childProcess3.spawn(command, cliArguments, childProcessOptions);
+  if (options.wait) {
+    return new Promise((resolve, reject) => {
+      subprocess.once("error", reject);
+      subprocess.once("close", (exitCode) => {
+        if (!options.allowNonzeroExitCode && exitCode !== 0) {
+          reject(new Error(`Exited with code ${exitCode}`));
+          return;
+        }
+        resolve(subprocess);
+      });
+    });
+  }
+  if (isFallbackAttempt) {
+    return new Promise((resolve, reject) => {
+      subprocess.once("error", reject);
+      subprocess.once("spawn", () => {
+        subprocess.once("close", (exitCode) => {
+          subprocess.off("error", reject);
+          if (exitCode !== 0) {
+            reject(new Error(`Exited with code ${exitCode}`));
+            return;
+          }
+          subprocess.unref();
+          resolve(subprocess);
+        });
+      });
+    });
+  }
+  subprocess.unref();
+  return new Promise((resolve, reject) => {
+    subprocess.once("error", reject);
+    subprocess.once("spawn", () => {
+      subprocess.off("error", reject);
+      resolve(subprocess);
+    });
+  });
+}, open = (target, options) => {
+  if (typeof target !== "string") {
+    throw new TypeError("Expected a `target`");
+  }
+  return baseOpen({
+    ...options,
+    target
+  });
+}, openApp = (name, options) => {
+  if (typeof name !== "string" && !Array.isArray(name)) {
+    throw new TypeError("Expected a valid `name`");
+  }
+  const { arguments: appArguments = [] } = options ?? {};
+  if (appArguments !== undefined && appArguments !== null && !Array.isArray(appArguments)) {
+    throw new TypeError("Expected `appArguments` as Array type");
+  }
+  return baseOpen({
+    ...options,
+    app: {
+      name,
+      arguments: appArguments
+    }
+  });
+}, apps, open_default;
+var init_open = __esm(() => {
+  init_wsl_utils();
+  init_powershell_utils();
+  init_default_browser();
+  init_is_inside_container();
+  init_is_in_ssh();
+  fallbackAttemptSymbol = Symbol("fallbackAttempt");
+  __dirname2 = import.meta.url ? path.dirname(fileURLToPath(import.meta.url)) : "";
+  localXdgOpenPath = path.join(__dirname2, "xdg-open");
+  ({ platform, arch } = process8);
+  apps = {
+    browser: "browser",
+    browserPrivate: "browserPrivate"
+  };
+  defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+    darwin: "google chrome",
+    win32: "chrome",
+    linux: ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]
+  }, {
+    wsl: {
+      ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+      x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+    }
+  }));
+  defineLazyProperty(apps, "brave", () => detectPlatformBinary({
+    darwin: "brave browser",
+    win32: "brave",
+    linux: ["brave-browser", "brave"]
+  }, {
+    wsl: {
+      ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+      x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
+    }
+  }));
+  defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+    darwin: "firefox",
+    win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+    linux: "firefox"
+  }, {
+    wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+  }));
+  defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+    darwin: "microsoft edge",
+    win32: "msedge",
+    linux: ["microsoft-edge", "microsoft-edge-dev"]
+  }, {
+    wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+  }));
+  defineLazyProperty(apps, "safari", () => detectPlatformBinary({
+    darwin: "Safari"
+  }));
+  open_default = open;
+});
+
+// ../../common/src/entity-name-rules.ts
+var RESERVED_SQL_KEYWORDS_LOWER = new Set(["group", "order"]);
+var ENTITY_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]{2,99}$/;
+var FIELD_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9]{2,99}$/;
+var RESERVED_FIELD_NAMES_LOWER = new Set([
+  "id",
+  "createdby",
+  "createtime",
+  "updatedby",
+  "updatetime",
+  "recordowner",
+  "version"
+]);
+var RESERVED_KEYWORDS_LOWER = new Set([
+  "abstract",
+  "as",
+  "base",
+  "bool",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "checked",
+  "class",
+  "const",
+  "continue",
+  "decimal",
+  "default",
+  "delegate",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "event",
+  "explicit",
+  "extern",
+  "false",
+  "finally",
+  "fixed",
+  "float",
+  "for",
+  "foreach",
+  "goto",
+  "if",
+  "implicit",
+  "in",
+  "int",
+  "interface",
+  "internal",
+  "is",
+  "lock",
+  "long",
+  "namespace",
+  "new",
+  "null",
+  "object",
+  "operator",
+  "out",
+  "override",
+  "params",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "ref",
+  "return",
+  "sbyte",
+  "sealed",
+  "short",
+  "sizeof",
+  "stackalloc",
+  "static",
+  "string",
+  "struct",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "uint",
+  "ulong",
+  "unchecked",
+  "unsafe",
+  "ushort",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "while",
+  "addhandler",
+  "addressof",
+  "alias",
+  "and",
+  "andalso",
+  "boolean",
+  "byref",
+  "byval",
+  "call",
+  "cbool",
+  "cbyte",
+  "cchar",
+  "cdate",
+  "cdbl",
+  "cdec",
+  "cint",
+  "clng",
+  "cobj",
+  "csbyte",
+  "cshort",
+  "csng",
+  "cstr",
+  "ctype",
+  "cuint",
+  "culng",
+  "cushort",
+  "date",
+  "declare",
+  "dim",
+  "directcast",
+  "each",
+  "elseif",
+  "end",
+  "endif",
+  "erase",
+  "error",
+  "exit",
+  "friend",
+  "function",
+  "get",
+  "gettype",
+  "getxmlnamespace",
+  "global",
+  "gosub",
+  "goto",
+  "handles",
+  "implements",
+  "imports",
+  "inherits",
+  "integer",
+  "isnot",
+  "let",
+  "lib",
+  "like",
+  "loop",
+  "me",
+  "mod",
+  "module",
+  "mustinherit",
+  "mustoverride",
+  "mybase",
+  "myclass",
+  "narrowing",
+  "next",
+  "not",
+  "nothing",
+  "notinheritable",
+  "notoverridable",
+  "of",
+  "on",
+  "option",
+  "optional",
+  "or",
+  "orelse",
+  "overloads",
+  "overridable",
+  "overrides",
+  "paramarray",
+  "partial",
+  "property",
+  "raiseevent",
+  "redim",
+  "rem",
+  "removehandler",
+  "resume",
+  "select",
+  "set",
+  "shadows",
+  "shared",
+  "single",
+  "step",
+  "stop",
+  "structure",
+  "sub",
+  "synclock",
+  "then",
+  "to",
+  "trycast",
+  "uinteger",
+  "ushort",
+  "variant",
+  "wend",
+  "when",
+  "widening",
+  "with",
+  "withevents",
+  "writeonly",
+  "xor"
+]);
+function findReservedNameError(name, kind) {
+  if (kind === "field" && RESERVED_FIELD_NAMES_LOWER.has(name.toLowerCase())) {
+    return {
+      message: `Field name '${name}' is reserved`,
+      instructions: "The following field names are reserved by the platform (case-insensitive): Id, CreatedBy, CreateTime, UpdatedBy, UpdateTime, RecordOwner, Version. Pick a different name."
+    };
+  }
+  if (RESERVED_KEYWORDS_LOWER.has(name.toLowerCase())) {
+    return {
+      message: `${kind === "entity" ? "Entity" : kind === "field" ? "Field" : "Choice set"} name '${name}' is a reserved C# or VB keyword`,
+      instructions: "Reserved keywords are rejected with RESERVED_LANGUAGE_KEYWORDS. Pick a domain-specific rename, for example 'Case' -> 'WorkItem', 'Class' -> 'Category', 'New' -> 'IsNew'."
+    };
+  }
+  if (kind === "entity" && RESERVED_SQL_KEYWORDS_LOWER.has(name.toLowerCase())) {
+    return {
+      message: `Entity name '${name}' is a reserved SQL keyword`,
+      instructions: "The platform rejects 'Order' and 'Group' as entity names. Pick a domain-specific name such as 'PurchaseOrder' or 'TeamGroup'."
+    };
+  }
+  return null;
+}
+function validateNameFormat(name, kind) {
+  const pattern = kind === "field" ? FIELD_NAME_PATTERN : ENTITY_NAME_PATTERN;
+  if (pattern.test(name)) {
+    return null;
+  }
+  return {
+    message: `Invalid ${kind} name '${name}'`,
+    instructions: kind === "field" ? "Field names must start with a letter, contain only letters and digits (no underscores), and be 3-100 characters long." : "Names must start with a letter, contain only letters, digits, and underscores, and be 3-100 characters long."
+  };
+}
+
+// ../../filesystem/src/node.ts
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import * as fs6 from "node:fs/promises";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
+var LOCK_HEARTBEAT_MS = 5000;
+var LOCK_STALE_MS = 15000;
+var LOCK_MAX_WAIT_MS = 20000;
+var LOCK_MAX_HOLD_MS = 60000;
+var LOCK_RETRY_MIN_MS = 100;
+var LOCK_RETRY_JITTER_MS = 200;
+
+class NodeFileSystem {
+  path = {
+    join: path2.join,
+    resolve: path2.resolve,
+    relative: path2.relative,
+    dirname: path2.dirname,
+    isAbsolute: path2.isAbsolute,
+    basename: path2.basename
+  };
+  env = {
+    cwd: process.cwd,
+    homedir: os2.homedir,
+    tmpdir: os2.tmpdir,
+    getenv: (key) => process.env[key]
+  };
+  utils = {
+    open: async (url) => {
+      const { default: open2 } = await Promise.resolve().then(() => (init_open(), exports_open));
+      await open2(url);
+    }
+  };
+  async readFile(path3, options) {
+    try {
+      if (options) {
+        return await fs6.readFile(path3, "utf-8");
+      }
+      return await fs6.readFile(path3);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+  }
+  async writeFile(filePath, data) {
+    const dir = path2.dirname(filePath);
+    if (dir) {
+      await fs6.mkdir(dir, { recursive: true });
+    }
+    await fs6.writeFile(filePath, data);
+  }
+  async appendFile(filePath, data) {
+    const dir = path2.dirname(filePath);
+    if (dir) {
+      await fs6.mkdir(dir, { recursive: true });
+    }
+    await fs6.appendFile(filePath, data);
+  }
+  async readdir(dirPath) {
+    try {
+      return await fs6.readdir(dirPath);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return [];
+      throw error;
+    }
+  }
+  async stat(filePath) {
+    try {
+      const stats = await fs6.stat(filePath);
+      return {
+        isFile: () => stats.isFile(),
+        isDirectory: () => stats.isDirectory(),
+        size: stats.size,
+        mtimeMs: stats.mtimeMs
+      };
+    } catch (error) {
+      if (this.isEnoent(error))
+        return null;
+      throw error;
+    }
+  }
+  async exists(filePath) {
+    return existsSync(filePath);
+  }
+  async mkdir(dirPath) {
+    await fs6.mkdir(dirPath, { recursive: true });
+  }
+  async acquireLock(lockPath) {
+    const canonicalPath = await this.canonicalizeLockTarget(lockPath);
+    const lockFile = `${canonicalPath}.lock`;
+    const ownerId = randomUUID();
+    const start = Date.now();
+    while (true) {
+      try {
+        await fs6.writeFile(lockFile, ownerId, { flag: "wx" });
+        return this.createLockRelease(lockFile, ownerId);
+      } catch (error) {
+        if (!this.hasErrnoCode(error, "EEXIST")) {
+          throw error;
+        }
+        const stats = await fs6.stat(lockFile).catch(() => null);
+        if (stats && Date.now() - stats.mtimeMs > LOCK_STALE_MS) {
+          const reclaimed = await fs6.rm(lockFile, { force: true }).then(() => true).catch(() => false);
+          if (reclaimed)
+            continue;
+        }
+        if (Date.now() - start > LOCK_MAX_WAIT_MS) {
+          throw new Error(`ELOCKED: timed out waiting for lock on ${canonicalPath}`);
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, LOCK_RETRY_MIN_MS + Math.random() * LOCK_RETRY_JITTER_MS));
+      }
+    }
+  }
+  async canonicalizeLockTarget(lockPath) {
+    const absolute = path2.resolve(lockPath);
+    const fullReal = await fs6.realpath(absolute).catch(() => null);
+    if (fullReal)
+      return fullReal;
+    const parent = path2.dirname(absolute);
+    const base = path2.basename(absolute);
+    const canonicalParent = await fs6.realpath(parent).catch(() => parent);
+    return path2.join(canonicalParent, base);
+  }
+  createLockRelease(lockFile, ownerId) {
+    const heartbeatStart = Date.now();
+    let heartbeatTimer;
+    let stopped = false;
+    const stopHeartbeat = () => {
+      stopped = true;
+      if (heartbeatTimer)
+        clearTimeout(heartbeatTimer);
+    };
+    const scheduleNextHeartbeat = () => {
+      if (stopped)
+        return;
+      if (Date.now() - heartbeatStart >= LOCK_MAX_HOLD_MS) {
+        stopped = true;
+        return;
+      }
+      heartbeatTimer = setTimeout(() => {
+        runHeartbeat();
+      }, LOCK_HEARTBEAT_MS);
+      heartbeatTimer.unref?.();
+    };
+    const runHeartbeat = async () => {
+      if (stopped)
+        return;
+      const current = await fs6.readFile(lockFile, "utf-8").catch(() => null);
+      if (stopped)
+        return;
+      if (current !== ownerId) {
+        stopped = true;
+        return;
+      }
+      const now = Date.now() / 1000;
+      await fs6.utimes(lockFile, now, now).catch(() => {});
+      scheduleNextHeartbeat();
+    };
+    scheduleNextHeartbeat();
+    let released = false;
+    return async () => {
+      if (released)
+        return;
+      released = true;
+      stopHeartbeat();
+      const current = await fs6.readFile(lockFile, "utf-8").catch(() => null);
+      if (current === ownerId) {
+        await fs6.rm(lockFile, { force: true });
+      }
+    };
+  }
+  async rm(filePath) {
+    await fs6.rm(filePath, { recursive: true, force: true });
+  }
+  async rename(oldPath, newPath) {
+    await fs6.rename(oldPath, newPath);
+  }
+  async isSymbolicLink(filePath) {
+    try {
+      return (await fs6.lstat(filePath)).isSymbolicLink();
+    } catch (error) {
+      if (this.isEnoent(error) || this.hasErrnoCode(error, "ENOTDIR")) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async realpath(filePath) {
+    try {
+      return await fs6.realpath(filePath);
+    } catch (error) {
+      if (this.isEnoent(error))
+        return filePath;
+      throw error;
+    }
+  }
+  async getTempDir() {
+    return await fs6.mkdtemp(path2.join(os2.tmpdir(), "uipath-fs-"));
+  }
+  async copyDirectory(sourcePath, destPath) {
+    const sourceStats = await this.stat(sourcePath);
+    if (!sourceStats) {
+      throw new Error(`Source directory does not exist: ${sourcePath}`);
+    }
+    if (!sourceStats.isDirectory()) {
+      throw new Error(`Source path is not a directory: ${sourcePath}`);
+    }
+    await this.mkdir(destPath);
+    const entries = await this.readdir(sourcePath);
+    for (const entry of entries) {
+      const srcEntry = path2.join(sourcePath, entry);
+      const destEntry = path2.join(destPath, entry);
+      const entryStats = await this.stat(srcEntry);
+      if (!entryStats)
+        continue;
+      if (entryStats.isDirectory()) {
+        await this.copyDirectory(srcEntry, destEntry);
+      } else if (entryStats.isFile()) {
+        const content = await this.readFile(srcEntry);
+        if (content !== null) {
+          await this.writeFile(destEntry, content);
+        }
+      }
+    }
+  }
+  isEnoent(error) {
+    return this.hasErrnoCode(error, "ENOENT");
+  }
+  hasErrnoCode(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+  }
+}
+
+// ../../filesystem/src/index.ts
+var fsInstance = new NodeFileSystem;
+var getFileSystem = () => fsInstance;
+
+// src/canonical-path.ts
+async function canonicalPathAsync(target, fs7) {
+  const realpath2 = fs7.realpath?.bind(fs7);
+  const absolute = fs7.path.resolve(target);
+  if (realpath2 === undefined)
+    return absolute;
+  const tail = [];
+  let current = absolute;
+  while (!await fs7.exists(current)) {
+    const parent = fs7.path.dirname(current);
+    if (parent === current)
+      return absolute;
+    tail.unshift(fs7.path.basename(current));
+    current = parent;
+  }
+  return fs7.path.join(await realpath2(current), ...tail);
+}
+async function resolvesInsideAsync(target, root, fs7) {
+  const canonicalRoot = await canonicalPathAsync(root, fs7);
+  const resolved = await canonicalPathAsync(target, fs7);
+  const relative2 = fs7.path.relative(canonicalRoot, resolved);
+  const inside = relative2 !== "" && relative2.split(/[\\/]/)[0] !== ".." && !fs7.path.isAbsolute(relative2);
+  return { inside, resolved, root: canonicalRoot };
+}
+async function isSymlinkEntryAsync(target, fs7) {
+  const isSymbolicLink = fs7.isSymbolicLink?.bind(fs7);
+  return isSymbolicLink === undefined ? false : isSymbolicLink(fs7.path.resolve(target));
+}
+
+// src/missing-path.ts
+function isMissingPathError(error) {
+  if (!(error instanceof Error) || !("code" in error))
+    return false;
+  const { code } = error;
+  return code === "ENOENT" || code === "ENOTDIR" || code === "PathNotFound";
+}
+function isFilesystemError(error) {
+  const code = error?.code;
+  return typeof code === "string" && /^E[A-Z]+$/.test(code);
+}
+function isUnreadablePathError(error) {
+  return isFilesystemError(error) && !isMissingPathError(error);
+}
+
+// src/pack/constants.ts
+var ENTITY_EXTENSION_CONST = ".entity";
+
+// ../../common/src/telemetry/pseudonymize.ts
+var PSEUDONYM_DOMAIN = "uipath-cli/telemetry/pseudonym/v1:";
+var PSEUDONYM_HEX_LENGTH = 32;
+var SHA256_K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_INITIAL_STATE = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+function rotr(value, bits) {
+  return (value >>> bits | value << 32 - bits) >>> 0;
+}
+function sha256Hex(input) {
+  const bytes = new TextEncoder().encode(input);
+  const paddedLength = bytes.length + 9 + 63 >> 6 << 6;
+  const buffer = new Uint8Array(paddedLength);
+  buffer.set(bytes);
+  buffer[bytes.length] = 128;
+  const view = new DataView(buffer.buffer);
+  const bitLength = bytes.length * 8;
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
+  view.setUint32(paddedLength - 4, bitLength >>> 0);
+  const state = SHA256_INITIAL_STATE.slice();
+  const schedule = new Uint32Array(64);
+  for (let offset = 0;offset < paddedLength; offset += 64) {
+    for (let i = 0;i < 16; i++) {
+      schedule[i] = view.getUint32(offset + i * 4);
+    }
+    for (let i = 16;i < 64; i++) {
+      const x = schedule[i - 15];
+      const y = schedule[i - 2];
+      const s0 = (rotr(x, 7) ^ rotr(x, 18) ^ x >>> 3) >>> 0;
+      const s1 = (rotr(y, 17) ^ rotr(y, 19) ^ y >>> 10) >>> 0;
+      schedule[i] = schedule[i - 16] + s0 + schedule[i - 7] + s1 >>> 0;
+    }
+    let a = state[0];
+    let b = state[1];
+    let c = state[2];
+    let d = state[3];
+    let e = state[4];
+    let f = state[5];
+    let g = state[6];
+    let h = state[7];
+    for (let i = 0;i < 64; i++) {
+      const s1 = (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) >>> 0;
+      const ch = (e & f ^ ~e & g) >>> 0;
+      const temp1 = h + s1 + ch + SHA256_K[i] + schedule[i] >>> 0;
+      const s0 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) >>> 0;
+      const maj = (a & b ^ a & c ^ b & c) >>> 0;
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    state[0] = state[0] + a >>> 0;
+    state[1] = state[1] + b >>> 0;
+    state[2] = state[2] + c >>> 0;
+    state[3] = state[3] + d >>> 0;
+    state[4] = state[4] + e >>> 0;
+    state[5] = state[5] + f >>> 0;
+    state[6] = state[6] + g >>> 0;
+    state[7] = state[7] + h >>> 0;
+  }
+  let hex = "";
+  for (const word of state) {
+    hex += word.toString(16).padStart(8, "0");
+  }
+  return hex;
+}
+function resolveSha256Hex() {
+  try {
+    const nodeCrypto = __require("node:crypto");
+    const createHash = nodeCrypto?.createHash;
+    if (typeof createHash !== "function") {
+      return sha256Hex;
+    }
+    const native = (input) => createHash("sha256").update(input, "utf8").digest("hex");
+    return native("abc") === sha256Hex("abc") ? native : sha256Hex;
+  } catch {
+    return sha256Hex;
+  }
+}
+var cachedSha256Hex;
+function digest(input) {
+  cachedSha256Hex ??= resolveSha256Hex();
+  return cachedSha256Hex(input);
+}
+function pseudonymize(input) {
+  return digest(`${PSEUDONYM_DOMAIN}${input}`).slice(0, PSEUDONYM_HEX_LENGTH);
+}
+
+// ../../common/src/singleton.ts
+var PREFIX = "@uipath/common/";
+var _g = globalThis;
+function singleton(ctorOrName) {
+  const name = typeof ctorOrName === "string" ? ctorOrName : ctorOrName.name;
+  const key = Symbol.for(PREFIX + name);
+  return {
+    get(fallback) {
+      return _g[key] ?? fallback;
+    },
+    set(value) {
+      _g[key] = value;
+    },
+    clear() {
+      delete _g[key];
+    },
+    getOrInit(factory, guard) {
+      const existing = _g[key];
+      if (existing != null && typeof existing === "object") {
+        if (!guard || guard(existing)) {
+          return existing;
+        }
+      }
+      const instance = factory();
+      _g[key] = instance;
+      return instance;
+    }
+  };
+}
+
+// ../../common/src/telemetry/supplied-values.ts
+var suppliedValuesSlot = singleton("TelemetrySuppliedArgumentValues");
+function activeEntries() {
+  const existing = suppliedValuesSlot.get();
+  return Array.isArray(existing) ? existing : [];
+}
+var MIN_SCRUBBABLE_LENGTH = 4;
+function recordSuppliedArgumentValues(values) {
+  const flat = [];
+  const push = (value) => {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        push(item);
+      }
+      return;
+    }
+    if (typeof value === "string" && value.length >= MIN_SCRUBBABLE_LENGTH) {
+      flat.push(value);
+    }
+  };
+  push(values);
+  const entry = { values: flat };
+  suppliedValuesSlot.set([...activeEntries(), entry]);
+  return entry;
+}
+function releaseSuppliedArgumentValues(entry) {
+  suppliedValuesSlot.set(activeEntries().filter((held) => held !== entry));
+}
+function getSuppliedArgumentValues() {
+  const all = new Set;
+  for (const entry of activeEntries()) {
+    for (const value of entry.values) {
+      all.add(value);
+    }
+  }
+  return [...all].sort((a, b) => b.length - a.length);
+}
+
+// ../../common/src/telemetry/pii-redactor.ts
+var REDACTED = "[REDACTED]";
+var MAX_VALUE_LENGTH = 280;
+var MAX_STACK_LENGTH = 4096;
+var MAX_SCAN_LENGTH = MAX_STACK_LENGTH;
+function truncate(value, maxLength) {
+  return value.length > maxLength ? `${value.slice(0, maxLength)}…` : value;
+}
+var SENSITIVE_NAME_TOKENS = new Set([
+  "token",
+  "tokens",
+  "secret",
+  "secrets",
+  "password",
+  "passwords",
+  "pwd",
+  "credential",
+  "credentials",
+  "auth",
+  "authentication",
+  "authorization",
+  "authority",
+  "cert",
+  "certificate",
+  "certificates"
+]);
+var SENSITIVE_KEY_PREFIXES = new Set([
+  "api",
+  "access",
+  "client",
+  "private",
+  "public",
+  "signing",
+  "encryption",
+  "session",
+  "master",
+  "shared",
+  "root",
+  "ssh",
+  "rsa",
+  "aes",
+  "hmac",
+  "oauth"
+]);
+var UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
+var EMAIL_PATTERN = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
+var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
+var LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
+var PADDED_BASE64_PATTERN = /(?<![A-Za-z0-9+/])[A-Za-z0-9+/]{16,}={1,2}(?![A-Za-z0-9+/=])/g;
+var BASE64_WITH_PLUS_PATTERN = /[A-Za-z0-9+/]{40,}/g;
+var USER_HOME_PATTERN = /(?<![A-Za-z0-9._-])([/\\])(Users|home|Profiles)([/\\])([^/\\]+)/gi;
+var UNC_PATH_PATTERN = /(^|[\s"'<>|=,;([{])(\\\\[^\s"'<>|]+)/g;
+var HOST_PORT_PATTERN = /(?<![/@.\w-])(?!\d+\.\d+\.\d+\.\d+:)[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?)+:\d{1,5}\b/g;
+var SOURCE_FILE_EXTENSIONS = new Set([
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "cts",
+  "mts",
+  "py",
+  "cs",
+  "java",
+  "go",
+  "rs",
+  "rb",
+  "php",
+  "sh",
+  "ps1",
+  "json",
+  "jsonc",
+  "yaml",
+  "yml",
+  "xml",
+  "xaml",
+  "md",
+  "txt",
+  "log",
+  "css",
+  "html",
+  "htm",
+  "csproj",
+  "nuspec",
+  "sql"
+]);
+var URL_PATTERN = /\bhttps?:\/\/[^\s,;]+/gi;
+var QUOTED_LITERAL_MAX_SPAN = 200;
+var QUOTED_LITERAL_PATTERN = new RegExp([
+  `(?<![A-Za-z0-9])'(?:[^\\
+]|\\.){2,${QUOTED_LITERAL_MAX_SPAN}}?'(?![A-Za-z0-9])`,
+  `(?<![A-Za-z0-9])"(?:[^\\
+]|\\.){2,${QUOTED_LITERAL_MAX_SPAN}}?"(?![A-Za-z0-9])`
+].join("|"), "g");
+var JSON_BODY_PATTERN = /[{[][^{}[\]:,]*[:,][^{}[\]]*[\]}]/g;
+var COLLAPSED_BODY = "{…}";
+var COLLAPSED_BODY_MARKER = "\x01body\x01";
+var MAX_BODY_NESTING = 8;
+function collapseJsonBodies(text) {
+  let out = text;
+  for (let pass = 0;pass < MAX_BODY_NESTING; pass++) {
+    const next = out.replace(JSON_BODY_PATTERN, COLLAPSED_BODY_MARKER);
+    if (next === out) {
+      break;
+    }
+    out = next;
+  }
+  return out.split(COLLAPSED_BODY_MARKER).join(COLLAPSED_BODY);
+}
+var TRAILING_PROSE_PUNCT = `.,;:!?)]}>'"`;
+function peelTrailingPunctuation(match) {
+  let end = match.length;
+  while (end > 0 && TRAILING_PROSE_PUNCT.includes(match[end - 1])) {
+    end -= 1;
+  }
+  return [match.slice(0, end), match.slice(end)];
+}
+function redactUrl(raw) {
+  try {
+    const url = new URL(raw);
+    return `${url.protocol}//${url.host}`;
+  } catch {
+    return `url#${pseudonymize(raw)}`;
+  }
+}
+function redactValueDetectors(value, maxLength = MAX_VALUE_LENGTH) {
+  let out = truncate(value, MAX_SCAN_LENGTH);
+  out = out.replace(JWT_PATTERN, () => REDACTED);
+  out = out.replace(URL_PATTERN, (match) => {
+    const [core, trailing] = peelTrailingPunctuation(match);
+    return `${redactUrl(core)}${trailing}`;
+  });
+  out = out.replace(USER_HOME_PATTERN, (_match, sep1, folder, sep2) => `${sep1}${folder}${sep2}<user>`);
+  out = out.replace(UNC_PATH_PATTERN, (_match, before, path3) => {
+    const [core, trailing] = peelTrailingPunctuation(path3);
+    return `${before}unc#${pseudonymize(core)}${trailing}`;
+  });
+  out = out.replace(EMAIL_PATTERN, (match) => `email#${pseudonymize(match)}`);
+  out = out.replace(UUID_PATTERN, (match) => `uuid#${pseudonymize(match)}`);
+  out = out.replace(HOST_PORT_PATTERN, (match) => {
+    const split = match.lastIndexOf(":");
+    const host = match.slice(0, split);
+    const extension = host.slice(host.lastIndexOf(".") + 1).toLowerCase();
+    if (SOURCE_FILE_EXTENSIONS.has(extension)) {
+      return match;
+    }
+    return `host#${pseudonymize(host)}:${match.slice(split + 1)}`;
+  });
+  out = out.replace(PADDED_BASE64_PATTERN, () => REDACTED);
+  out = out.replace(BASE64_WITH_PLUS_PATTERN, (match) => match.includes("+") ? REDACTED : match);
+  out = out.replace(LONG_TOKEN_PATTERN, () => REDACTED);
+  return truncate(out, maxLength);
+}
+function redactSpanName(name) {
+  return redactValueDetectors(truncate(name, MAX_SCAN_LENGTH).replace(QUOTED_LITERAL_PATTERN, (match) => `${match[0]}<redacted>${match[0]}`));
+}
+var HTTP_DEPENDENCY_NAME = /^([A-Z]+) (\/.*)$/s;
+function redactHttpDependencyName(name) {
+  const parts = HTTP_DEPENDENCY_NAME.exec(name);
+  if (!parts) {
+    return redactMessage(name);
+  }
+  return `${parts[1]} ${redactMessage(parts[2])}`;
+}
+function redactMessage(value) {
+  let out = collapseJsonBodies(truncate(value, MAX_SCAN_LENGTH)).replace(QUOTED_LITERAL_PATTERN, (match) => `${match[0]}<redacted>${match[0]}`);
+  for (const supplied of getSuppliedArgumentValues()) {
+    out = out.split(supplied).join(REDACTED);
+  }
+  return redactValueDetectors(out);
+}
+var MESSAGE_NAMES = new Set([
+  "message",
+  "errormessage",
+  "errmessage",
+  "error_message",
+  "msg",
+  "detail",
+  "details",
+  "reason",
+  "instructions",
+  "warning"
+]);
+function isFreeFormValue(name, value) {
+  return MESSAGE_NAMES.has(name.toLowerCase()) || /['"{[]/.test(value);
+}
+function redactError(error) {
+  const safe = new Error(redactMessage(error.message ?? ""));
+  safe.name = error.name;
+  safe.stack = typeof error.stack === "string" ? redactStack(error.stack) : undefined;
+  return safe;
+}
+function redactStack(stack) {
+  const bounded = truncate(stack, MAX_STACK_LENGTH);
+  const firstBreak = bounded.indexOf(`
+`);
+  if (firstBreak === -1) {
+    return redactMessage(bounded);
+  }
+  return `${redactMessage(bounded.slice(0, firstBreak))}
+${redactValueDetectors(bounded.slice(firstBreak + 1), MAX_STACK_LENGTH)}`;
+}
+function nameTokens(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s._-]+/).map((t) => t.toLowerCase()).filter(Boolean);
+}
+function isSensitiveName(name) {
+  const tokens = nameTokens(name);
+  for (let i = 0;i < tokens.length; i++) {
+    const token = tokens[i];
+    if (SENSITIVE_NAME_TOKENS.has(token)) {
+      return true;
+    }
+    if (token === "key" || token === "keys") {
+      const prev = tokens[i - 1];
+      if (prev && SENSITIVE_KEY_PREFIXES.has(prev)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function redactProperty(name, value) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (isSensitiveName(name)) {
+    return REDACTED;
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return "[OBJECT]";
+  }
+  return isFreeFormValue(name, value) ? redactMessage(value) : redactValueDetectors(value);
+}
+function redactProperties(properties) {
+  const out = {};
+  for (const [name, value] of Object.entries(properties)) {
+    const redacted = redactProperty(name, value);
+    if (redacted !== undefined) {
+      out[name] = redacted;
+    }
+  }
+  return out;
+}
+
+// ../../common/src/catch-error.ts
+var MAX_SERIALIZED_LENGTH = 500;
+var TRUNCATION_SUFFIX = "…(truncated)";
+var REDACTED2 = "[REDACTED]";
+function cap(text) {
+  return text.length > MAX_SERIALIZED_LENGTH ? `${text.slice(0, MAX_SERIALIZED_LENGTH)}${TRUNCATION_SUFFIX}` : text;
+}
+function omitSensitive(key, value) {
+  return key.length > 0 && isSensitiveName(key) ? REDACTED2 : value;
+}
+function describeThrownValue(value) {
+  if (typeof value !== "object" || value === null) {
+    return String(value);
+  }
+  let message;
+  try {
+    message = value.message;
+  } catch {
+    message = undefined;
+  }
+  if (typeof message === "string" && message.length > 0) {
+    return cap(message);
+  }
+  try {
+    const json = JSON.stringify(value, omitSensitive);
+    if (json !== undefined) {
+      return cap(json);
+    }
+  } catch {}
+  return String(value);
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(describeThrownValue(error), { cause: error });
+}
+function isPromiseLike(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function catchError(fnOrPromise) {
+  if (isPromiseLike(fnOrPromise)) {
+    return settlePromiseLike(fnOrPromise);
+  }
+  try {
+    const result = fnOrPromise();
+    if (isPromiseLike(result)) {
+      return settlePromiseLike(result);
+    }
+    return [undefined, result];
+  } catch (error) {
+    return [toError(error), undefined];
+  }
+}
+function settlePromiseLike(thenable) {
+  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [toError(error), undefined]);
+}
+
+// src/resource/unified-resource-file.ts
+var ENTITY_RESOURCE_KIND = "entity";
+var ENTITY_RESOURCE_TYPE = "native";
+var ENTITY_RESOURCE_API_VERSION = "dataservice.uipath.com/v2";
+var ENTITY_RESOURCE_DOC_VERSION = "1.0.0";
+var SOLUTION_FOLDER = "solution_folder";
+var ENTITY_RESOURCE_DIR = `${ENTITY_RESOURCE_KIND}/${ENTITY_RESOURCE_TYPE}`;
+function entityResourcePath(entityName) {
+  return `resources/${SOLUTION_FOLDER}/${ENTITY_RESOURCE_DIR}/${entityName}.json`;
+}
+
+// src/resource/resource-io.ts
+function serialize(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function serializeEntityJson(entity) {
+  return JSON.stringify(entity);
+}
+
+class EntityResourceError extends Error {
+  failure;
+  constructor(failure, message) {
+    super(message);
+    this.failure = failure;
+    this.name = "EntityResourceError";
+  }
+}
+function wrapEntityJson(entity) {
+  return {
+    docVersion: ENTITY_RESOURCE_DOC_VERSION,
+    resource: {
+      name: entity.Name,
+      kind: ENTITY_RESOURCE_KIND,
+      type: ENTITY_RESOURCE_TYPE,
+      apiVersion: ENTITY_RESOURCE_API_VERSION,
+      isOverridable: true,
+      dependencies: [],
+      runtimeDependencies: [],
+      folders: [{ fullyQualifiedName: SOLUTION_FOLDER }],
+      spec: {
+        resourceJson: serializeEntityJson(entity),
+        name: entity.Name,
+        displayName: entity.DisplayName,
+        description: entity.Description
+      },
+      locks: [],
+      key: entity.Id,
+      files: []
+    }
+  };
+}
+function unwrapResource(file) {
+  if (typeof file !== "object" || file === null || Array.isArray(file)) {
+    throw new EntityResourceError("NotAnObject", "Resource file is not a JSON object.");
+  }
+  const resource = file.resource;
+  if (typeof resource !== "object" || resource === null) {
+    throw new EntityResourceError("MissingResource", "Resource file has no 'resource' object.");
+  }
+  if (resource.kind !== ENTITY_RESOURCE_KIND) {
+    throw new EntityResourceError("NotAnEntityResource", `Resource kind is '${String(resource.kind)}', expected '${ENTITY_RESOURCE_KIND}'.`);
+  }
+  const spec = resource.spec;
+  if (typeof spec !== "object" || spec === null || typeof spec.resourceJson !== "string") {
+    throw new EntityResourceError("MissingSpec", "Resource file has no 'spec.resourceJson' string.");
+  }
+  try {
+    return JSON.parse(spec.resourceJson);
+  } catch {
+    throw new EntityResourceError("ResourceJsonUnparsable", "'spec.resourceJson' is not valid JSON.");
+  }
+}
+function updateResourceSchema(file, entity) {
+  return {
+    ...file,
+    resource: {
+      ...file.resource,
+      name: entity.Name,
+      spec: {
+        ...file.resource.spec,
+        resourceJson: serializeEntityJson(entity),
+        name: entity.Name,
+        displayName: entity.DisplayName,
+        description: entity.Description
+      }
+    }
+  };
+}
+
+// src/pack/verify-pair.ts
+async function verifyPair(stubFile, solutionDir, fs7) {
+  const parsedStub = await readStub(stubFile, fs7);
+  if ("failure" in parsedStub) {
+    return { ok: false, failure: parsedStub.failure };
+  }
+  const stub = parsedStub.stub;
+  const baseName = fs7.path.basename(stubFile, ENTITY_EXTENSION_CONST);
+  if (baseName !== stub.name) {
+    return fail("StubFileNameMismatch", `Stub file '${baseName}${ENTITY_EXTENSION_CONST}' names entity '${stub.name}' — the filename and the entity name must match.`);
+  }
+  const solutionRoot = fs7.path.resolve(solutionDir);
+  const resourceFile = fs7.path.resolve(solutionRoot, ...stub.resourcePath.split("/"));
+  const boundary = resourceFile.charAt(solutionRoot.length);
+  if (!resourceFile.startsWith(solutionRoot) || boundary !== "/" && boundary !== "\\") {
+    return fail("ResourcePathEscapes", `'${stub.name}': resourcePath '${stub.resourcePath}' points outside the solution.`);
+  }
+  const parsedResource = await readResource(resourceFile, stub.name, stub.resourcePath, fs7);
+  if ("failure" in parsedResource) {
+    return { ok: false, failure: parsedResource.failure };
+  }
+  const resourceRaw = parsedResource.raw;
+  let entity;
+  try {
+    entity = unwrapResource(resourceRaw);
+  } catch (error) {
+    const detail = error instanceof EntityResourceError ? ` (${error.failure})` : "";
+    return fail("ResourceInvalid", `'${stub.name}': resource '${stub.resourcePath}' is not a valid entity resource${detail}.`);
+  }
+  if (entity.Name !== stub.name) {
+    return fail("NameCoupling", `Stub '${stub.name}' points at a resource defining entity '${entity.Name}' — the names must match.`);
+  }
+  return { ok: true, entityName: stub.name, resourceFile, entity };
+}
+function fail(code, message) {
+  return { ok: false, failure: { code, message } };
+}
+async function readStub(stubFile, fs7) {
+  let parsed;
+  try {
+    const raw = await fs7.readFile(stubFile);
+    if (raw === null) {
+      return failure("StubUnparsable", `'${stubFile}' could not be read.`);
+    }
+    parsed = JSON.parse(decode(raw));
+  } catch {
+    return failure("StubUnparsable", `'${stubFile}' is not valid JSON.`);
+  }
+  if (typeof parsed !== "object" || parsed === null || typeof parsed.name !== "string" || typeof parsed.resourcePath !== "string") {
+    return failure("StubUnparsable", `'${stubFile}' must be an object with string 'name' and 'resourcePath'.`);
+  }
+  return { stub: { name: parsed.name, resourcePath: parsed.resourcePath } };
+}
+async function readResource(resourceFile, entityName, resourcePath, fs7) {
+  const missing = failure("ResourceMissing", `'${entityName}': definition resource '${resourcePath}' is missing. Restore it (check trash/backup) or delete the entity.`);
+  try {
+    const raw = await fs7.readFile(resourceFile);
+    if (raw === null) {
+      return missing;
+    }
+    return { raw: JSON.parse(decode(raw)) };
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return failure("ResourceInvalid", `'${entityName}': resource '${resourcePath}' is not valid JSON.`);
+    }
+    return missing;
+  }
+}
+function decode(raw) {
+  return typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+}
+function failure(code, message) {
+  return { failure: { code, message } };
+}
+async function findSolutionRoot(startDir, fs7) {
+  let dir = fs7.path.resolve(startDir);
+  let unreadable;
+  for (;; ) {
+    const [error, entries] = await catchError(fs7.readdir(dir));
+    if (error && isUnreadablePathError(error)) {
+      unreadable ??= error;
+    }
+    if (entries?.some((name) => name.endsWith(".uipx"))) {
+      if (unreadable) {
+        throw Object.assign(new Error(`Could not locate the solution from '${startDir}': ${unreadable.message}. A directory between here and the nearest .uipx cannot be read, and it may be the solution itself — fix read access and retry.`, { cause: unreadable }), { code: unreadable.code });
+      }
+      return dir;
+    }
+    const parent = fs7.path.dirname(dir);
+    if (parent === dir) {
+      return;
+    }
+    dir = parent;
+  }
+}
+
+// ../../common/src/entity-field-rules.ts
+var MAX_SAFE_NUMERIC_BOUND = 9007199254740991;
+var LENGTH_LIMIT_RANGES = {
+  STRING: [1, 4000],
+  MULTILINE_TEXT: [1, 1e4],
+  MULTILINE_MAX: [1, 131072]
+};
+var MAX_MULTILINE_MAX_FIELDS = 10;
+function isNumber(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function findInvalidFieldConstraints(fields) {
+  for (const f of fields) {
+    if (typeof f !== "object" || f === null)
+      continue;
+    const rec = f;
+    const type = rec.type;
+    if (typeof type !== "string")
+      continue;
+    const fieldName = typeof rec.name === "string" ? rec.name : "<field>";
+    if (rec.lengthLimit !== undefined) {
+      if (!isNumber(rec.lengthLimit) || !Number.isInteger(rec.lengthLimit)) {
+        return {
+          message: `Field '${fieldName}' 'lengthLimit' must be an integer`,
+          instructions: "Pass a positive integer within the type's range (STRING 1-4000, MULTILINE_TEXT 1-10000, MULTILINE_MAX 1-131072 UTF-16 bytes)."
+        };
+      }
+      const range = LENGTH_LIMIT_RANGES[type];
+      if (range === undefined) {
+        return {
+          message: `Field '${fieldName}' of type '${type}' does not accept 'lengthLimit'`,
+          instructions: "'lengthLimit' applies only to STRING, MULTILINE_TEXT, and MULTILINE_MAX. Remove it or change the field type."
+        };
+      }
+      const [min, max] = range;
+      if (rec.lengthLimit < min || rec.lengthLimit > max) {
+        return {
+          message: `Field '${fieldName}' 'lengthLimit' ${rec.lengthLimit} is outside the allowed range for type '${type}'`,
+          instructions: `'lengthLimit' on '${type}' must be between ${min} and ${max}. MULTILINE_MAX 'lengthLimit' is a UTF-16 byte budget (≈2 per char).`
+        };
+      }
+    }
+    if (rec.maxValue !== undefined || rec.minValue !== undefined) {
+      if (type !== "DECIMAL" && type !== "AUTO_NUMBER") {
+        const which = rec.maxValue !== undefined ? "maxValue" : "minValue";
+        return {
+          message: `Field '${fieldName}' of type '${type}' does not accept '${which}'`,
+          instructions: "'minValue' and 'maxValue' apply only to DECIMAL and AUTO_NUMBER. Remove them or change the field type."
+        };
+      }
+      if (rec.maxValue !== undefined && !isNumber(rec.maxValue)) {
+        return {
+          message: `Field '${fieldName}' 'maxValue' must be a number`,
+          instructions: "Pass a numeric value."
+        };
+      }
+      if (rec.minValue !== undefined && !isNumber(rec.minValue)) {
+        return {
+          message: `Field '${fieldName}' 'minValue' must be a number`,
+          instructions: "Pass a numeric value."
+        };
+      }
+      const maxValue = rec.maxValue;
+      if (maxValue !== undefined && (maxValue > MAX_SAFE_NUMERIC_BOUND || maxValue < -MAX_SAFE_NUMERIC_BOUND)) {
+        return {
+          message: `Field '${fieldName}' 'maxValue' ${rec.maxValue} is outside the supported numeric range`,
+          instructions: `Use a value between ${-MAX_SAFE_NUMERIC_BOUND} and ${MAX_SAFE_NUMERIC_BOUND}.`
+        };
+      }
+      const minValue = rec.minValue;
+      if (minValue !== undefined && (minValue > MAX_SAFE_NUMERIC_BOUND || minValue < -MAX_SAFE_NUMERIC_BOUND)) {
+        return {
+          message: `Field '${fieldName}' 'minValue' ${rec.minValue} is outside the supported numeric range`,
+          instructions: `Use a value between ${-MAX_SAFE_NUMERIC_BOUND} and ${MAX_SAFE_NUMERIC_BOUND}.`
+        };
+      }
+      if (rec.maxValue !== undefined && rec.minValue !== undefined && rec.minValue > rec.maxValue) {
+        return {
+          message: `Field '${fieldName}' 'minValue' (${rec.minValue}) must not exceed 'maxValue' (${rec.maxValue})`,
+          instructions: "Adjust the bounds so 'minValue <= maxValue', or drop one of the two."
+        };
+      }
+    }
+    if (rec.decimalPrecision !== undefined) {
+      if (type !== "DECIMAL" && type !== "AUTO_NUMBER") {
+        return {
+          message: `Field '${fieldName}' of type '${type}' does not accept 'decimalPrecision'`,
+          instructions: "'decimalPrecision' applies only to DECIMAL and AUTO_NUMBER. Remove it or change the field type."
+        };
+      }
+      if (!isNumber(rec.decimalPrecision) || !Number.isInteger(rec.decimalPrecision) || rec.decimalPrecision < 0 || rec.decimalPrecision > 10) {
+        return {
+          message: `Field '${fieldName}' 'decimalPrecision' ${rec.decimalPrecision} is invalid`,
+          instructions: "'decimalPrecision' must be an integer between 0 and 10 (0 for whole numbers, 2 for money)."
+        };
+      }
+    }
+  }
+  return null;
+}
+
+// ../../../node_modules/@uipath/entity-modeler/dist/chunk-7VKIHCI7.js
+var SqlTypeName = {
+  UNIQUEIDENTIFIER: "UNIQUEIDENTIFIER",
+  NVARCHAR: "NVARCHAR",
+  INT: "INT",
+  DATETIME2: "DATETIME2",
+  DATETIMEOFFSET: "DATETIMEOFFSET",
+  FLOAT: "FLOAT",
+  REAL: "REAL",
+  BIGINT: "BIGINT",
+  DATE: "DATE",
+  BIT: "BIT",
+  DECIMAL: "DECIMAL",
+  MULTILINE: "MULTILINE",
+  MULTILINE_MAX: "MULTILINE_MAX",
+  UNKNOWN: "UNKNOWN"
+};
+var FieldDisplayType = {
+  Basic: "Basic",
+  Relationship: "Relationship",
+  File: "File",
+  ChoiceSetSingle: "ChoiceSetSingle",
+  ChoiceSetMultiple: "ChoiceSetMultiple",
+  AutoNumber: "AutoNumber",
+  MultiLineText: "MultiLineText"
+};
+var DEFAULT_REFERENCE_TYPE = "ManyToOne";
+var CSHARP_RESERVED_WORDS = [
+  "__arglist",
+  "__makeref",
+  "__reftype",
+  "__refvalue",
+  "abstract",
+  "as",
+  "base",
+  "bool",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "checked",
+  "class",
+  "const",
+  "continue",
+  "decimal",
+  "default",
+  "delegate",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "event",
+  "explicit",
+  "extern",
+  "false",
+  "finally",
+  "fixed",
+  "float",
+  "for",
+  "foreach",
+  "goto",
+  "if",
+  "implicit",
+  "in",
+  "int",
+  "interface",
+  "internal",
+  "is",
+  "lock",
+  "long",
+  "namespace",
+  "new",
+  "null",
+  "object",
+  "operator",
+  "out",
+  "override",
+  "params",
+  "partial",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "ref",
+  "return",
+  "sbyte",
+  "sealed",
+  "short",
+  "sizeof",
+  "stackalloc",
+  "static",
+  "string",
+  "struct",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "uint",
+  "ulong",
+  "unchecked",
+  "unsafe",
+  "ushort",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "where",
+  "while",
+  "yield"
+];
+var VB_RESERVED_WORDS = [
+  "addhandler",
+  "addressof",
+  "alias",
+  "and",
+  "andalso",
+  "ansi",
+  "as",
+  "assembly",
+  "auto",
+  "boolean",
+  "byref",
+  "byte",
+  "byval",
+  "call",
+  "case",
+  "catch",
+  "cbool",
+  "cbyte",
+  "cchar",
+  "cdate",
+  "cdbl",
+  "cdec",
+  "char",
+  "cint",
+  "class",
+  "class_finalize",
+  "class_initialize",
+  "clng",
+  "cobj",
+  "const",
+  "continue",
+  "csbyte",
+  "cshort",
+  "csng",
+  "cstr",
+  "ctype",
+  "cuint",
+  "culng",
+  "cushort",
+  "date",
+  "decimal",
+  "declare",
+  "default",
+  "delegate",
+  "dim",
+  "directcast",
+  "do",
+  "double",
+  "each",
+  "else",
+  "elseif",
+  "end",
+  "endif",
+  "enum",
+  "erase",
+  "error",
+  "event",
+  "exit",
+  "false",
+  "finally",
+  "for",
+  "friend",
+  "function",
+  "get",
+  "gettype",
+  "global",
+  "gosub",
+  "goto",
+  "handles",
+  "if",
+  "implements",
+  "imports",
+  "in",
+  "inherits",
+  "integer",
+  "interface",
+  "is",
+  "isnot",
+  "let",
+  "lib",
+  "like",
+  "long",
+  "loop",
+  "me",
+  "mod",
+  "module",
+  "mustinherit",
+  "mustoverride",
+  "mybase",
+  "myclass",
+  "namespace",
+  "narrowing",
+  "new",
+  "next",
+  "not",
+  "nothing",
+  "notinheritable",
+  "notoverridable",
+  "object",
+  "of",
+  "on",
+  "operator",
+  "option",
+  "optional",
+  "or",
+  "orelse",
+  "overloads",
+  "overridable",
+  "overrides",
+  "paramarray",
+  "partial",
+  "preserve",
+  "private",
+  "property",
+  "protected",
+  "public",
+  "raiseevent",
+  "readonly",
+  "redim",
+  "rem",
+  "removehandler",
+  "resume",
+  "return",
+  "sbyte",
+  "select",
+  "set",
+  "shadows",
+  "shared",
+  "short",
+  "single",
+  "static",
+  "step",
+  "stop",
+  "string",
+  "structure",
+  "sub",
+  "synclock",
+  "then",
+  "throw",
+  "to",
+  "true",
+  "try",
+  "trycast",
+  "typeof",
+  "uinteger",
+  "ulong",
+  "unicode",
+  "until",
+  "ushort",
+  "using",
+  "variant",
+  "wend",
+  "when",
+  "while",
+  "widening",
+  "with",
+  "withevents",
+  "writeonly",
+  "xor"
+];
+var CSHARP_RESERVED = new Set(CSHARP_RESERVED_WORDS);
+var VB_RESERVED = new Set(VB_RESERVED_WORDS);
+var GA_TYPE_PAIRS = [
+  [FieldDisplayType.Basic, SqlTypeName.NVARCHAR],
+  [FieldDisplayType.Basic, SqlTypeName.DECIMAL],
+  [FieldDisplayType.Basic, SqlTypeName.FLOAT],
+  [FieldDisplayType.Basic, SqlTypeName.BIT],
+  [FieldDisplayType.Basic, SqlTypeName.DATE],
+  [FieldDisplayType.Basic, SqlTypeName.DATETIMEOFFSET],
+  [FieldDisplayType.Basic, SqlTypeName.UNIQUEIDENTIFIER],
+  [FieldDisplayType.AutoNumber, SqlTypeName.DECIMAL],
+  [FieldDisplayType.Basic, SqlTypeName.MULTILINE],
+  [FieldDisplayType.Basic, SqlTypeName.MULTILINE_MAX],
+  [FieldDisplayType.File, SqlTypeName.UNIQUEIDENTIFIER]
+];
+var ALLOWED_TYPE_PAIRS = new Set(GA_TYPE_PAIRS.map(([display, sql]) => `${display}:${sql}`));
+// src/sort-names.ts
+function byName(a, b) {
+  return a.localeCompare(b, "en");
+}
+
+// src/schema/author-field.ts
+var TYPE_MAP = {
+  STRING: [FieldDisplayType.Basic, SqlTypeName.NVARCHAR],
+  DECIMAL: [FieldDisplayType.Basic, SqlTypeName.DECIMAL],
+  BOOLEAN: [FieldDisplayType.Basic, SqlTypeName.BIT],
+  DATE: [FieldDisplayType.Basic, SqlTypeName.DATE],
+  DATETIME_WITH_TZ: [FieldDisplayType.Basic, SqlTypeName.DATETIMEOFFSET],
+  MULTILINE_TEXT: [FieldDisplayType.Basic, SqlTypeName.MULTILINE],
+  MULTILINE_MAX: [FieldDisplayType.Basic, SqlTypeName.MULTILINE_MAX],
+  AUTO_NUMBER: [FieldDisplayType.AutoNumber, SqlTypeName.DECIMAL],
+  FILE: [FieldDisplayType.File, SqlTypeName.UNIQUEIDENTIFIER]
+};
+var AUTHORABLE_FIELD_TYPES = Object.freeze(Object.keys(TYPE_MAP).sort(byName));
+var UNAUTHORABLE_TYPES = {
+  CHOICE_SET_SINGLE: "choice-set fields are not authorable locally — add the field in Data Fabric",
+  CHOICE_SET_MULTIPLE: "choice-set fields are not authorable locally — add the field in Data Fabric",
+  RELATIONSHIP: "relationship fields are not authorable locally — add the field in Data Fabric",
+  INTEGER: "use DECIMAL with decimalPrecision: 0",
+  BIG_INTEGER: "use DECIMAL with decimalPrecision: 0",
+  FLOAT: "use DECIMAL with a decimalPrecision",
+  DOUBLE: "use DECIMAL with a decimalPrecision",
+  UUID: "use STRING",
+  DATETIME: "use DATETIME_WITH_TZ"
+};
+
+class AuthoredFieldError extends Error {
+  instructions;
+  constructor(message, instructions) {
+    super(message);
+    this.instructions = instructions;
+    this.name = "AuthoredFieldError";
+  }
+}
+function buildSqlType(name, spec) {
+  const sqlType = { Name: name };
+  if (spec.lengthLimit != null)
+    sqlType.LengthLimit = spec.lengthLimit;
+  if (spec.decimalPrecision != null)
+    sqlType.DecimalPrecision = spec.decimalPrecision;
+  if (spec.maxValue != null)
+    sqlType.MaxValue = spec.maxValue;
+  if (spec.minValue != null)
+    sqlType.MinValue = spec.minValue;
+  return sqlType;
+}
+var DEFAULT_VALUE_SHAPES = {
+  BOOLEAN: '"true" or "false"',
+  DECIMAL: 'a number in quotes, e.g. "0"',
+  AUTO_NUMBER: 'a number in quotes, e.g. "0"'
+};
+function assertDefaultValue(spec, checkContent) {
+  const value = spec.defaultValue;
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (!checkContent) {
+    return;
+  }
+  if (typeof value !== "string") {
+    const shape = DEFAULT_VALUE_SHAPES[spec.type] ?? "a string";
+    throw new AuthoredFieldError(`Field '${spec.name}': 'defaultValue' must be a string or null`, `Received ${JSON.stringify(value)}. Entity documents store every default as text, whatever the field type — for ${spec.type} pass ${shape}, or null to clear it.`);
+  }
+  if (spec.type === "BOOLEAN" && value.toLowerCase() !== "true" && value.toLowerCase() !== "false") {
+    throw new AuthoredFieldError(`Field '${spec.name}': 'defaultValue' ${JSON.stringify(value)} is not a boolean`, 'A BOOLEAN default is the text "true" or "false".');
+  }
+  if ((spec.type === "DECIMAL" || spec.type === "AUTO_NUMBER") && (value.trim() === "" || !Number.isFinite(Number(value)))) {
+    throw new AuthoredFieldError(`Field '${spec.name}': 'defaultValue' ${JSON.stringify(value)} is not a number`, `A ${spec.type} default is a number written as text, e.g. "0".`);
+  }
+}
+function authorField(spec, options = {}) {
+  const pair = TYPE_MAP[spec.type];
+  if (pair === undefined) {
+    const redirect = UNAUTHORABLE_TYPES[spec.type];
+    throw new AuthoredFieldError(`Field '${spec.name}' has unsupported type '${spec.type}'`, redirect === undefined ? `Supported types: ${AUTHORABLE_FIELD_TYPES.join(", ")}.` : `${redirect}. Supported types: ${AUTHORABLE_FIELD_TYPES.join(", ")}.`);
+  }
+  const [fieldDisplayType, sqlTypeName] = pair;
+  const pairKey = `${fieldDisplayType}:${sqlTypeName}`;
+  if (!ALLOWED_TYPE_PAIRS.has(pairKey)) {
+    throw new AuthoredFieldError(`Internal: type '${spec.type}' maps to ${pairKey}, which is not an allowed pair`, "This is a defect in author-field.ts — the type map has drifted from GA_TYPE_PAIRS.");
+  }
+  for (const [key, value] of [
+    ["isRequired", spec.isRequired],
+    ["isUnique", spec.isUnique]
+  ]) {
+    if (value !== undefined && typeof value !== "boolean") {
+      throw new AuthoredFieldError(`Field '${spec.name}': '${key}' must be true or false`, `Received ${JSON.stringify(value)}. Use a JSON boolean, not a string.`);
+    }
+  }
+  for (const [key, value] of [
+    ["displayName", spec.displayName],
+    ["description", spec.description]
+  ]) {
+    if (value !== undefined && typeof value !== "string") {
+      throw new AuthoredFieldError(`Field '${spec.name}': '${key}' must be a string`, `Received ${JSON.stringify(value)}.`);
+    }
+  }
+  assertDefaultValue(spec, options.defaultValueFromCaller !== false);
+  const constraintError = findInvalidFieldConstraints([
+    {
+      name: spec.name,
+      type: spec.type,
+      ...spec.lengthLimit != null && {
+        lengthLimit: spec.lengthLimit
+      },
+      ...spec.decimalPrecision != null && {
+        decimalPrecision: spec.decimalPrecision
+      },
+      ...spec.maxValue != null && { maxValue: spec.maxValue },
+      ...spec.minValue != null && { minValue: spec.minValue }
+    }
+  ]);
+  if (constraintError) {
+    throw new AuthoredFieldError(constraintError.message, constraintError.instructions);
+  }
+  return {
+    Name: spec.name,
+    DisplayName: spec.displayName ?? spec.name,
+    SqlType: buildSqlType(sqlTypeName, spec),
+    IsRequired: spec.isRequired ?? false,
+    IsUnique: spec.isUnique ?? false,
+    IsPrimaryKey: false,
+    IsForeignKey: false,
+    IsExternalField: false,
+    IsHiddenField: false,
+    FieldCategoryId: 0,
+    ReferenceType: DEFAULT_REFERENCE_TYPE,
+    Transformation: null,
+    IsEncrypted: false,
+    Description: spec.description ?? "",
+    IsSystemField: false,
+    FieldDisplayType: fieldDisplayType,
+    DefaultValue: spec.defaultValue ?? null,
+    IsAttachment: false,
+    IsRbacEnabled: false,
+    IsModelReserved: false,
+    ReferenceChoiceSet: null,
+    ReferenceEntity: null,
+    ReferenceField: null,
+    ReferenceName: null
+  };
+}
+
+// src/schema/create-entity-skeleton.ts
+var UNASSIGNED_FOLDER_ID = "99999999-9999-9999-9999-999999999999";
+function isLocallyAuthored(entity) {
+  return entity.FolderId === UNASSIGNED_FOLDER_ID;
+}
+var SYSTEM_FIELD_DEFAULTS = {
+  IsPrimaryKey: false,
+  IsForeignKey: false,
+  IsExternalField: false,
+  IsHiddenField: true,
+  FieldCategoryId: 0,
+  IsUnique: false,
+  ReferenceType: "ManyToOne",
+  Transformation: null,
+  IsRequired: false,
+  IsEncrypted: false,
+  Description: "",
+  IsSystemField: true,
+  FieldDisplayType: FieldDisplayType.Basic,
+  IsAttachment: false,
+  IsRbacEnabled: false,
+  IsModelReserved: false
+};
+var SYSTEM_FIELD_TEMPLATES = [
+  {
+    ...SYSTEM_FIELD_DEFAULTS,
+    Name: "Id",
+    DisplayName: "Id",
+    IsPrimaryKey: true,
+    SqlType: { Name: SqlTypeName.UNIQUEIDENTIFIER }
+  },
+  {
+    ...SYSTEM_FIELD_DEFAULTS,
+    Name: "CreateTime",
+    DisplayName: "CreateTime",
+    SqlType: { Name: SqlTypeName.DATETIMEOFFSET }
+  },
+  {
+    ...SYSTEM_FIELD_DEFAULTS,
+    Name: "CreatedBy",
+    DisplayName: "CreatedBy",
+    FieldDisplayType: FieldDisplayType.Relationship,
+    SqlType: { Name: SqlTypeName.UNIQUEIDENTIFIER }
+  },
+  {
+    ...SYSTEM_FIELD_DEFAULTS,
+    Name: "UpdateTime",
+    DisplayName: "UpdateTime",
+    SqlType: { Name: SqlTypeName.DATETIMEOFFSET }
+  },
+  {
+    ...SYSTEM_FIELD_DEFAULTS,
+    Name: "UpdatedBy",
+    DisplayName: "UpdatedBy",
+    FieldDisplayType: FieldDisplayType.Relationship,
+    SqlType: { Name: SqlTypeName.UNIQUEIDENTIFIER }
+  }
+];
+function createEntitySkeleton(name) {
+  return {
+    Id: globalThis.crypto.randomUUID(),
+    Name: name,
+    DisplayName: name,
+    EntityTypeId: 0,
+    EntityType: "Entity",
+    Description: "",
+    FolderId: UNASSIGNED_FOLDER_ID,
+    Fields: SYSTEM_FIELD_TEMPLATES.map((template) => ({
+      ...template,
+      SqlType: { ...template.SqlType }
+    })),
+    Data: null,
+    ExternalFields: null,
+    SourceJoinCriterias: null,
+    RecordCount: 0,
+    StorageSizeInMB: null,
+    UsedStorageSizeInMB: null,
+    AttachmentSizeInByte: null,
+    IsRbacEnabled: false,
+    InvalidIdentifiers: [],
+    IsModelReserved: false,
+    CategoryId: null
+  };
+}
+function requireAuthoredName(authored, entityName) {
+  if (authored !== undefined && authored.Name !== entityName) {
+    throw new AuthoredFieldError(`Authored entity '${authored.Name}' cannot be written as '${entityName}'`, "Author the document with the name it is created under.");
+  }
+}
+
+// src/schema/solution-entity-names.ts
+function withoutOneOccurrence(names, name) {
+  const siblings = [...names];
+  const self = siblings.indexOf(name);
+  if (self >= 0) {
+    siblings.splice(self, 1);
+  }
+  return siblings;
+}
+function isMissingPath(error) {
+  return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "PathNotFound");
+}
+async function collectSolutionEntityNames(solutionDir, fs7) {
+  const names = [];
+  let topLevel = [];
+  try {
+    topLevel = await fs7.readdir(solutionDir);
+  } catch (error) {
+    if (!isMissingPath(error)) {
+      throw error;
+    }
+    return names;
+  }
+  for (const entry of topLevel) {
+    if (entry === "resources" || entry.startsWith(".")) {
+      continue;
+    }
+    const dir = fs7.path.join(solutionDir, entry);
+    try {
+      const stat2 = await fs7.stat(dir);
+      if (!stat2?.isDirectory()) {
+        continue;
+      }
+      for (const file of await fs7.readdir(dir)) {
+        if (file.endsWith(ENTITY_EXTENSION_CONST)) {
+          names.push(fs7.path.basename(file, ENTITY_EXTENSION_CONST));
+        }
+      }
+    } catch (error) {
+      if (!isMissingPath(error)) {
+        throw error;
+      }
+    }
+  }
+  return names;
+}
+async function siblingNamesFor(solutionDir, entityName, fs7) {
+  return withoutOneOccurrence(await collectSolutionEntityNames(solutionDir, fs7), entityName);
+}
+async function findProjectsOwningEntity(solutionDir, entityName, fs7) {
+  const owners = [];
+  const wanted = `${entityName}${ENTITY_EXTENSION_CONST}`.toLowerCase();
+  let topLevel = [];
+  try {
+    topLevel = await fs7.readdir(solutionDir);
+  } catch (error) {
+    if (isMissingPathError(error))
+      return owners;
+    throw error;
+  }
+  for (const entry of topLevel) {
+    if (entry === "resources" || entry.startsWith(".")) {
+      continue;
+    }
+    const dir = fs7.path.join(solutionDir, entry);
+    try {
+      const stat2 = await fs7.stat(dir);
+      if (!stat2?.isDirectory()) {
+        continue;
+      }
+      for (const file of await fs7.readdir(dir)) {
+        if (file.toLowerCase() === wanted) {
+          owners.push({
+            projectName: entry,
+            entityName: fs7.path.basename(file, ENTITY_EXTENSION_CONST)
+          });
+          break;
+        }
+      }
+    } catch (error) {
+      if (!isMissingPathError(error))
+        throw error;
+    }
+  }
+  return owners;
+}
+
+// src/schema/validate-entity.ts
+var DIAGNOSTIC_CODES = {
+  entityNameInvalid: "ENTITY_NAME_INVALID",
+  entityNameNotUnique: "ENTITY_NAME_NOT_UNIQUE",
+  fieldNameInvalid: "FIELD_NAME_INVALID",
+  duplicateFieldName: "DUPLICATE_FIELD_NAME",
+  fieldTypeNotAllowed: "FIELD_TYPE_NOT_ALLOWED",
+  nameReserved: "NAME_RESERVED",
+  systemFieldMissing: "SYSTEM_FIELD_MISSING",
+  systemFieldModified: "SYSTEM_FIELD_MODIFIED",
+  fieldsMalformed: "FIELDS_MALFORMED",
+  tooManyMultilineMax: "TOO_MANY_MULTILINE_MAX",
+  propertyTypeInvalid: "PROPERTY_TYPE_INVALID"
+};
+function validateEntity(entity, ctx) {
+  const diagnostics = [];
+  if (typeof entity?.Name !== "string") {
+    return [
+      {
+        code: DIAGNOSTIC_CODES.entityNameInvalid,
+        message: "The entity document has no 'Name'. The resource is malformed.",
+        severity: "error"
+      }
+    ];
+  }
+  const entityNameFormat = validateNameFormat(entity.Name, "entity");
+  if (entityNameFormat) {
+    diagnostics.push({
+      code: DIAGNOSTIC_CODES.entityNameInvalid,
+      message: `${entityNameFormat.message}. ${entityNameFormat.instructions}`,
+      severity: "error"
+    });
+  }
+  const reservedEntityName = findReservedNameError(entity.Name, "entity");
+  if (reservedEntityName) {
+    diagnostics.push({
+      code: DIAGNOSTIC_CODES.nameReserved,
+      message: `${reservedEntityName.message}. ${reservedEntityName.instructions}`,
+      severity: "error"
+    });
+  }
+  const entityNameLower = entity.Name.toLowerCase();
+  if (ctx.siblingNames.some((sibling) => sibling.toLowerCase() === entityNameLower)) {
+    diagnostics.push({
+      code: DIAGNOSTIC_CODES.entityNameNotUnique,
+      message: `An entity named '${entity.Name}' already exists in this solution. Entity names are solution-wide unique.`,
+      severity: "error"
+    });
+  }
+  diagnostics.push(...typeProblems(entity, ENTITY_SCALARS).map((problem) => propertyTypeDiagnostic(`Entity '${entity.Name}'`, problem)));
+  if (!Array.isArray(entity.Fields)) {
+    diagnostics.push({
+      code: DIAGNOSTIC_CODES.fieldsMalformed,
+      message: "The entity document has no usable 'Fields' array. The resource is malformed.",
+      severity: "error"
+    });
+    return diagnostics;
+  }
+  const seenFieldNames = new Map;
+  for (const field of entity.Fields) {
+    if (typeof field?.Name !== "string") {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.fieldNameInvalid,
+        message: "A field has no 'Name'. Every field needs one, system or custom.",
+        severity: "error"
+      });
+      continue;
+    }
+    const isSystem = isSystemField(field);
+    if (!SYSTEM_FIELD_NAMES.has(field.Name)) {
+      diagnostics.push(...fieldTypeDiagnostics(field));
+    }
+    const fieldNameFormat = isSystem ? null : validateNameFormat(field.Name, "field");
+    if (fieldNameFormat) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.fieldNameInvalid,
+        message: `${fieldNameFormat.message}. ${fieldNameFormat.instructions}`,
+        severity: "error",
+        fieldName: field.Name
+      });
+    }
+    if (!isSystem) {
+      const reservedFieldName = findReservedNameError(field.Name, "field");
+      if (reservedFieldName) {
+        diagnostics.push({
+          code: DIAGNOSTIC_CODES.nameReserved,
+          message: `${reservedFieldName.message}. ${reservedFieldName.instructions}`,
+          severity: "error",
+          fieldName: field.Name
+        });
+      }
+    }
+    const fieldNameLower = field.Name.toLowerCase();
+    if (!isSystem && typeof entity.Name === "string" && fieldNameLower === entity.Name.toLowerCase()) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.fieldNameInvalid,
+        message: `Field name '${field.Name}' cannot match entity name '${entity.Name}' (names are compared case-insensitively).`,
+        severity: "error",
+        fieldName: field.Name
+      });
+    }
+    const firstWithName = seenFieldNames.get(fieldNameLower);
+    if (firstWithName !== undefined) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.duplicateFieldName,
+        message: `Duplicate field name '${field.Name}' (names are case-insensitive; first defined as '${firstWithName}').`,
+        severity: "error",
+        fieldName: field.Name
+      });
+    } else {
+      seenFieldNames.set(fieldNameLower, field.Name);
+    }
+    if (!isSystem && !ALLOWED_TYPE_PAIRS.has(`${field.FieldDisplayType}:${field.SqlType?.Name}`)) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.fieldTypeNotAllowed,
+        message: `Field '${field.Name}' uses an unsupported type combination ` + `(${field.FieldDisplayType} / ${field.SqlType?.Name}).`,
+        severity: "error",
+        fieldName: field.Name
+      });
+    }
+  }
+  const usableFields = entity.Fields.filter((field) => typeof field === "object" && field !== null);
+  const multilineMax = usableFields.filter((field) => field.SqlType?.Name === SqlTypeName.MULTILINE_MAX);
+  if (multilineMax.length > MAX_MULTILINE_MAX_FIELDS) {
+    diagnostics.push({
+      code: DIAGNOSTIC_CODES.tooManyMultilineMax,
+      message: `Entity '${entity.Name}' defines ${multilineMax.length} MULTILINE_MAX fields; ` + `the maximum is ${MAX_MULTILINE_MAX_FIELDS}. Remove some, or use MULTILINE_TEXT where the content fits.`,
+      severity: "error"
+    });
+  }
+  diagnostics.push(...validateSystemFields(entity, usableFields));
+  return diagnostics;
+}
+var SERVER_ASSIGNED_FIELD_PROPS = new Set([
+  "Id",
+  "CreateTime",
+  "CreatedBy",
+  "UpdateTime",
+  "UpdatedBy"
+]);
+function isUnmodifiedSystemField(template, actual) {
+  const equal = (left, right) => JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+  for (const key of Object.keys(template)) {
+    if (!equal(template[key], actual[key])) {
+      return false;
+    }
+  }
+  return Object.keys(actual).every((key) => (key in template) || SERVER_ASSIGNED_FIELD_PROPS.has(key));
+}
+function validateSystemFields(entity, usableFields) {
+  const diagnostics = [];
+  for (const template of SYSTEM_FIELD_TEMPLATES) {
+    const actual = usableFields.find((field) => field.Name === template.Name);
+    if (!actual) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.systemFieldMissing,
+        message: `System field '${template.Name}' is missing. System fields cannot be removed.`,
+        severity: "error",
+        fieldName: template.Name
+      });
+      continue;
+    }
+    if (!isUnmodifiedSystemField(template, actual)) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.systemFieldModified,
+        message: `System field '${template.Name}' was modified. System fields are read-only.`,
+        severity: "error",
+        fieldName: template.Name
+      });
+    }
+  }
+  return diagnostics;
+}
+function isSystemField(field) {
+  const { IsSystemField: flag, Name: name } = field ?? {};
+  return flag === true || typeof name === "string" && SYSTEM_FIELD_NAMES.has(name);
+}
+var SYSTEM_FIELD_NAMES = new Set(SYSTEM_FIELD_TEMPLATES.map((template) => template.Name));
+var ENTITY_SCALARS = [
+  { key: "DisplayName", kind: "string" },
+  { key: "Description", kind: "string" },
+  { key: "EntityTypeId", kind: "integer" },
+  { key: "RecordCount", kind: "integer" },
+  { key: "IsRbacEnabled", kind: "boolean" },
+  { key: "IsModelReserved", kind: "boolean" }
+];
+var FIELD_SCALARS = [
+  { key: "DisplayName", kind: "string" },
+  { key: "Description", kind: "string" },
+  { key: "ReferenceType", kind: "string" },
+  { key: "FieldCategoryId", kind: "integer" },
+  { key: "IsRequired", kind: "boolean" },
+  { key: "IsUnique", kind: "boolean" },
+  { key: "IsPrimaryKey", kind: "boolean" },
+  { key: "IsForeignKey", kind: "boolean" },
+  { key: "IsSystemField", kind: "boolean" },
+  { key: "IsExternalField", kind: "boolean" },
+  { key: "IsHiddenField", kind: "boolean" },
+  { key: "IsEncrypted", kind: "boolean" },
+  { key: "IsAttachment", kind: "boolean" },
+  { key: "IsRbacEnabled", kind: "boolean" },
+  { key: "IsModelReserved", kind: "boolean" }
+];
+var SQL_TYPE_SCALARS = [
+  { key: "LengthLimit", kind: "integer", nullable: true },
+  { key: "DecimalPrecision", kind: "integer", nullable: true },
+  { key: "MaxValue", kind: "number", nullable: true },
+  { key: "MinValue", kind: "number", nullable: true }
+];
+function typeProblems(record, rules, prefix = "") {
+  const values = record;
+  return rules.filter(({ key, kind, nullable }) => {
+    const value = values[key];
+    if (value === undefined)
+      return false;
+    if (value === null)
+      return !nullable;
+    if (kind === "integer")
+      return !Number.isInteger(value);
+    return kind === "number" ? !(typeof value === "number" && Number.isFinite(value)) : typeof value !== kind;
+  }).map(({ key, kind, nullable }) => `'${prefix}${key}' must be ${kind === "integer" ? "an" : "a"} ${kind}${nullable ? " or null" : ""}`);
+}
+function propertyTypeDiagnostic(subject, problem, fieldName) {
+  return {
+    code: DIAGNOSTIC_CODES.propertyTypeInvalid,
+    message: `${subject}: ${problem}. The resource was edited by hand or is malformed.`,
+    severity: "error",
+    ...fieldName !== undefined && { fieldName }
+  };
+}
+function fieldTypeDiagnostics(field) {
+  const problems = typeProblems(field, FIELD_SCALARS);
+  if (typeof field.SqlType === "object" && field.SqlType !== null) {
+    problems.push(...typeProblems(field.SqlType, SQL_TYPE_SCALARS, "SqlType."));
+  }
+  const defaultValue = field.DefaultValue;
+  const isYesNo = field.SqlType?.Name === SqlTypeName.BIT;
+  if (defaultValue != null && typeof defaultValue !== "string" && !(isYesNo && typeof defaultValue === "boolean")) {
+    problems.push(isYesNo ? "'DefaultValue' must be a boolean, a string or null" : "'DefaultValue' must be a string or null");
+  }
+  return problems.map((problem) => propertyTypeDiagnostic(`Field '${field.Name}'`, problem, field.Name));
+}
+
+// src/inline/inline-entity-service.ts
+var INLINE_ENTITY_ERROR_CODES = {
+  projectNotFound: "PROJECT_NOT_FOUND",
+  noParentSolution: "NO_PARENT_SOLUTION",
+  entityNotFound: "ENTITY_NOT_FOUND",
+  notLocallyAuthored: "NOT_LOCALLY_AUTHORED"
+};
+
+class InlineEntityError extends Error {
+  instructions;
+  code;
+  constructor(message, instructions, code) {
+    super(message);
+    this.instructions = instructions;
+    this.code = code;
+    this.name = "InlineEntityError";
+  }
+}
+function fsOf() {
+  return getFileSystem();
+}
+var VALID_PROJECT_NAME = /^[a-zA-Z0-9_-]+$/;
+var PRESERVED_FIELD_PROPS = [
+  "Id",
+  "IsEncrypted",
+  "IsRbacEnabled",
+  "IsHiddenField",
+  "IsAttachment",
+  "Transformation",
+  "FieldCategoryId",
+  "ReferenceEntity",
+  "ReferenceField",
+  "ReferenceType",
+  "ReferenceChoiceSet",
+  "ReferenceName",
+  "CreateTime",
+  "CreatedBy",
+  "UpdateTime",
+  "UpdatedBy"
+];
+async function assertInsideSolutionAsync(target, solutionDir, fs7) {
+  const { inside, resolved, root } = await resolvesInsideAsync(target, solutionDir, fs7);
+  if (!inside) {
+    throw new InlineEntityError(`'${target}' resolves outside the solution`, `It leads to '${resolved}' once symlinks are followed. Projects and entity definitions must live inside the solution at '${root}'; replace the link with the directory or file itself.`);
+  }
+  if (await isSymlinkEntryAsync(target, fs7)) {
+    throw new InlineEntityError(`'${target}' is a symbolic link`, "Entity stubs and definition resources must be real files, not links — a link is followed by every read and write, wherever it points. Replace it with the file itself.");
+  }
+}
+async function containmentProblemAsync(target, solutionDir, fs7) {
+  try {
+    await assertInsideSolutionAsync(target, solutionDir, fs7);
+    return;
+  } catch (error) {
+    if (error instanceof InlineEntityError)
+      return error.message;
+    throw error;
+  }
+}
+async function checkedPairAsync(stubFile, solutionDir, fs7) {
+  const stubProblem = await containmentProblemAsync(stubFile, solutionDir, fs7);
+  if (stubProblem !== undefined)
+    return { ok: false, problem: stubProblem };
+  const pointed = await lexicalResourcePathAsync(stubFile, solutionDir, fs7);
+  if (pointed !== undefined) {
+    const resourceProblem = await containmentProblemAsync(pointed, solutionDir, fs7);
+    if (resourceProblem !== undefined) {
+      return { ok: false, problem: resourceProblem };
+    }
+  }
+  const pair = await verifyPair(stubFile, solutionDir, fs7);
+  return pair.ok ? { ok: true, pair } : { ok: false, problem: pair.failure.message };
+}
+async function lexicalResourcePathAsync(stubFile, solutionDir, fs7) {
+  let pointer;
+  try {
+    const raw = await fs7.readFile(stubFile);
+    pointer = JSON.parse(typeof raw === "string" ? raw : new TextDecoder().decode(raw ?? new Uint8Array)).resourcePath;
+  } catch {
+    return;
+  }
+  return typeof pointer === "string" ? fs7.path.resolve(solutionDir, ...pointer.split("/")) : undefined;
+}
+function assertEntityTextInput(input) {
+  for (const key of ["displayName", "description"]) {
+    const value = input[key];
+    if (value !== undefined && typeof value !== "string") {
+      throw new InlineEntityError(`'${key}' must be a string`, `Received ${JSON.stringify(value)}. Pass text, or "" for none.`);
+    }
+  }
+}
+async function solutionRootAsync(options = {}) {
+  const fs7 = fsOf();
+  const from = options.cwd ?? process.cwd();
+  const root = await findSolutionRoot(from, fs7);
+  if (root === undefined) {
+    throw new InlineEntityError("Not inside a solution", `Looked upward from '${from}' for a .uipx. Run this from the solution directory, or create one with 'uip solution init'.`, INLINE_ENTITY_ERROR_CODES.noParentSolution);
+  }
+  return root;
+}
+async function resolveProjectAsync(projectName, options = {}) {
+  const fs7 = fsOf();
+  if (!VALID_PROJECT_NAME.test(projectName)) {
+    throw new InlineEntityError(`Invalid project name '${projectName}'`, "Project names contain only letters, numbers, underscores (_) and hyphens (-) — they are a single directory name, never a path.");
+  }
+  const root = await solutionRootAsync(options);
+  const projectDir = fs7.path.resolve(root, projectName);
+  if (await isSymlinkEntryAsync(projectDir, fs7)) {
+    throw new InlineEntityError(`Entity project '${projectName}' is a symbolic link`, "A project is addressed by its own directory in the solution — a link would have stubs written wherever it points. Replace the link with the directory itself.");
+  }
+  let stat2 = null;
+  try {
+    stat2 = await fs7.stat(projectDir);
+  } catch (error) {
+    if (!isMissingPathError(error)) {
+      throw error;
+    }
+    stat2 = null;
+  }
+  if (stat2 === null || !stat2.isDirectory()) {
+    throw new InlineEntityError(`Entity project '${projectName}' not found`, `Looked for '${projectDir}'. Run the command from the solution directory, or create the project with 'uip df entities create <Name> --local --project-name ${projectName}'.`, INLINE_ENTITY_ERROR_CODES.projectNotFound);
+  }
+  await assertInsideSolutionAsync(projectDir, root, fs7);
+  return { projectDir, solutionDir: root };
+}
+async function registeredProjectTypesAsync(solutionDir, fs7) {
+  const registered = new Map;
+  for (const file of await fs7.readdir(solutionDir)) {
+    if (!file.endsWith(".uipx"))
+      continue;
+    const raw = await fs7.readFile(fs7.path.join(solutionDir, file), "utf-8");
+    let projects;
+    try {
+      projects = JSON.parse(typeof raw === "string" ? raw : new TextDecoder().decode(raw ?? new Uint8Array)).Projects;
+    } catch {
+      throw new InlineEntityError(`Solution manifest '${file}' is not valid JSON`, `Fix '${fs7.path.join(solutionDir, file)}' — 'uip solution pack' cannot read it either.`);
+    }
+    for (const project of Array.isArray(projects) ? projects : []) {
+      const { Type, ProjectRelativePath } = project ?? {};
+      if (typeof Type === "string" && typeof ProjectRelativePath === "string") {
+        const segments = ProjectRelativePath.split(/[\\/]/);
+        const key = segments.length === 2 ? segments[0]?.toLowerCase() : undefined;
+        if (key && registered.get(key)?.toLowerCase() !== "entity") {
+          registered.set(key, Type);
+        }
+      }
+    }
+  }
+  return registered;
+}
+async function requireEntityProjectAsync(projectDir, projectName, solutionDir, fs7) {
+  const projectFile = fs7.path.join(projectDir, "project.uiproj");
+  let raw = null;
+  try {
+    raw = await fs7.readFile(projectFile, "utf-8");
+  } catch (error) {
+    if (!isMissingPathError(error)) {
+      throw error;
+    }
+    raw = null;
+  }
+  if (raw === null) {
+    throw new InlineEntityError(`Directory '${projectName}' is not an Entity project`, `No 'project.uiproj' in '${projectDir}'. An entity can only be authored into a project of type Entity — create one with 'uip df entities create <Name> --local --project-name <NewProject>'.`);
+  }
+  let projectType;
+  try {
+    projectType = JSON.parse(typeof raw === "string" ? raw : new TextDecoder().decode(raw)).ProjectType;
+  } catch {
+    throw new InlineEntityError(`Project file for '${projectName}' is not valid JSON`, `Fix '${projectFile}' — it must be a JSON object naming a 'ProjectType'.`);
+  }
+  if (typeof projectType !== "string" || projectType.toLowerCase() !== "entity") {
+    throw new InlineEntityError(`Project '${projectName}' is not an Entity project`, `'${projectFile}' declares ProjectType '${String(projectType)}'. Pack only ships entities from a project of type Entity, so an entity written here would never deploy. Use an Entity project, or create one with 'uip df entities create <Name> --local --project-name <NewProject>'.`);
+  }
+  await requireRegisteredAsync(projectName, solutionDir, fs7);
+}
+async function requireRegisteredAsync(projectName, solutionDir, fs7) {
+  const type = (await registeredProjectTypesAsync(solutionDir, fs7)).get(projectName.toLowerCase());
+  if (type !== undefined && type.toLowerCase() !== "entity") {
+    throw new InlineEntityError(`Project '${projectName}' is registered as '${type}', not as an Entity project`, `The solution's .uipx lists '${projectName}' as a ${type} project, so pack never reads entities from it. Author entities in an Entity project — create one with 'uip df entities create <Name> --local --project-name <NewProject>'.`);
+  }
+  if (type === undefined) {
+    throw new InlineEntityError(`Entity project '${projectName}' is not registered in the solution`, `'${projectName}' is not in the solution's .uipx as an Entity project, so 'uip solution pack' never visits it and nothing written there would deploy. Register it with 'uip solution projects add ${projectName}'.`);
+  }
+}
+function entityStubPath(projectDir, entityName, fs7) {
+  const nameError = validateNameFormat(entityName, "entity");
+  if (nameError) {
+    throw new InlineEntityError(nameError.message, nameError.instructions);
+  }
+  const stubFile = fs7.path.join(projectDir, `${entityName}${ENTITY_EXTENSION_CONST}`);
+  if (fs7.path.dirname(fs7.path.resolve(stubFile)) !== fs7.path.resolve(projectDir)) {
+    throw new InlineEntityError(`Entity name '${entityName}' does not resolve inside project directory`, "Entity names are plain identifiers, never paths.");
+  }
+  return stubFile;
+}
+async function resolveOwningProjectAsync(entityName, options = {}) {
+  const fs7 = fsOf();
+  const from = options.cwd ?? process.cwd();
+  const solutionDir = await findSolutionRoot(from, fs7);
+  if (solutionDir === undefined) {
+    throw new InlineEntityError("Not inside a solution", `Looked upward from '${from}' for a .uipx. Run this from the solution directory, or name the project with --project-name.`, INLINE_ENTITY_ERROR_CODES.noParentSolution);
+  }
+  const owners = await findProjectsOwningEntity(solutionDir, entityName, fs7);
+  const owner = owners[0];
+  if (owners.length === 1 && owner !== undefined) {
+    return {
+      projectName: owner.projectName,
+      entityName: owner.entityName,
+      solutionDir
+    };
+  }
+  if (owners.length === 0) {
+    const known = await collectSolutionEntityNames(solutionDir, fs7);
+    throw new InlineEntityError(`No entity named '${entityName}' in this solution`, known.length === 0 ? "The solution has no authored entities yet. Create one with 'uip df entities create <Name> --local'." : `Entities here: ${[...new Set(known)].sort(byName).join(", ")}.`, INLINE_ENTITY_ERROR_CODES.entityNotFound);
+  }
+  throw new InlineEntityError(`More than one project owns an entity named '${entityName}'`, `Found in: ${owners.map((each) => each.projectName).join(", ")}. Name the one you mean with --project-name.`);
+}
+async function stubNamesAsync(projectDir, fs7) {
+  let entries = [];
+  try {
+    entries = await fs7.readdir(projectDir);
+  } catch (error) {
+    if (!isMissingPathError(error)) {
+      throw error;
+    }
+    return [];
+  }
+  return entries.filter((name) => name.endsWith(ENTITY_EXTENSION_CONST)).sort(byName);
+}
+async function inlineEntityListAsync(projectName, options = {}) {
+  const fs7 = fsOf();
+  const { projectDir, solutionDir } = await resolveProjectAsync(projectName, options);
+  await requireRegisteredAsync(projectName, solutionDir, fs7);
+  const summaries = [];
+  for (const stubName of await stubNamesAsync(projectDir, fs7)) {
+    const stubFile = fs7.path.join(projectDir, stubName);
+    const checked = await checkedPairAsync(stubFile, solutionDir, fs7);
+    if (!checked.ok) {
+      summaries.push({
+        name: fs7.path.basename(stubName, ENTITY_EXTENSION_CONST),
+        stubFile,
+        problem: checked.problem
+      });
+      continue;
+    }
+    const { pair } = checked;
+    summaries.push({
+      name: pair.entityName,
+      stubFile,
+      resourceFile: pair.resourceFile,
+      locallyAuthored: isLocallyAuthored(pair.entity)
+    });
+  }
+  return summaries;
+}
+async function inlineEntityListAllAsync(options = {}) {
+  const fs7 = fsOf();
+  const from = options.cwd ?? process.cwd();
+  const solutionDir = await findSolutionRoot(from, fs7);
+  if (solutionDir === undefined) {
+    throw new InlineEntityError("Not inside a solution", `Looked upward from '${from}' for a .uipx. Run this from the solution directory.`, INLINE_ENTITY_ERROR_CODES.noParentSolution);
+  }
+  const rows = [];
+  for (const entry of (await fs7.readdir(solutionDir)).sort(byName)) {
+    if (entry === "resources" || entry.startsWith(".")) {
+      continue;
+    }
+    const dir = fs7.path.join(solutionDir, entry);
+    const [statError, stat2] = await catchInline(() => fs7.stat(dir));
+    if (statError !== undefined && !isMissingPathError(statError)) {
+      rows.push({
+        projectName: entry,
+        name: entry,
+        stubFile: dir,
+        solutionDir,
+        projectProblem: `Directory '${entry}' could not be read: ${messageOf(statError)}`
+      });
+      continue;
+    }
+    if (!stat2?.isDirectory()) {
+      continue;
+    }
+    const [readError, entries] = await catchInline(() => fs7.readdir(dir));
+    if (readError !== undefined) {
+      if (isMissingPathError(readError)) {
+        continue;
+      }
+      rows.push({
+        projectName: entry,
+        name: entry,
+        stubFile: dir,
+        solutionDir,
+        projectProblem: `Directory '${entry}' could not be read: ${messageOf(readError)}`
+      });
+      continue;
+    }
+    if (!(entries ?? []).some((file) => file.endsWith(ENTITY_EXTENSION_CONST))) {
+      continue;
+    }
+    const [listError, listed] = await catchInline(() => inlineEntityListAsync(entry, { cwd: solutionDir }));
+    if (listError !== undefined) {
+      rows.push({
+        projectName: entry,
+        name: entry,
+        stubFile: dir,
+        solutionDir,
+        projectProblem: listError instanceof InlineEntityError && listError.instructions ? `${listError.message}. ${listError.instructions}` : messageOf(listError)
+      });
+      continue;
+    }
+    for (const summary of listed ?? []) {
+      rows.push({ ...summary, projectName: entry, solutionDir });
+    }
+  }
+  return rows;
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function catchInline(run) {
+  try {
+    return [undefined, await run()];
+  } catch (error) {
+    return [error, undefined];
+  }
+}
+async function resolveEntityAsync(projectName, entityName, options) {
+  const fs7 = fsOf();
+  const { projectDir, solutionDir } = await resolveProjectAsync(projectName, options);
+  const stubFile = entityStubPath(projectDir, entityName, fs7);
+  const checked = await checkedPairAsync(stubFile, solutionDir, fs7);
+  if (!checked.ok) {
+    const known = (await stubNamesAsync(projectDir, fs7)).map((name) => fs7.path.basename(name, ENTITY_EXTENSION_CONST));
+    throw new InlineEntityError(`Entity '${entityName}' is not usable in project '${projectName}': ${checked.problem}`, known.length === 0 ? `Project '${projectName}' has no entities. Add one with 'uip df entities create ${entityName} --local --project-name ${projectName}'.` : `Entities in this project: ${known.join(", ")}.`);
+  }
+  const { pair } = checked;
+  await assertInsideSolutionAsync(pair.resourceFile, solutionDir, fs7);
+  const rawResource = await fs7.readFile(pair.resourceFile, "utf-8");
+  if (rawResource === null) {
+    throw new InlineEntityError(`Entity definition for '${pair.entityName}' could not be read`, `Expected it at '${pair.resourceFile}'.`);
+  }
+  const resource = JSON.parse(rawResource);
+  return {
+    projectDir,
+    solutionDir,
+    entityName: pair.entityName,
+    stubFile,
+    resourceFile: pair.resourceFile,
+    entity: pair.entity,
+    resource
+  };
+}
+async function inlineEntityGetAsync(projectName, entityName, options = {}) {
+  return (await resolveEntityAsync(projectName, entityName, options)).entity;
+}
+async function inlineEntityValidateAsync(projectName, options = {}) {
+  const fs7 = fsOf();
+  const { projectDir, solutionDir } = await resolveProjectAsync(projectName, options);
+  await requireRegisteredAsync(projectName, solutionDir, fs7);
+  const stubFiles = options.entityName === undefined ? (await stubNamesAsync(projectDir, fs7)).map((stubName) => fs7.path.join(projectDir, stubName)) : [entityStubPath(projectDir, options.entityName, fs7)];
+  const results = [];
+  for (const stubFile of stubFiles) {
+    const name = fs7.path.basename(stubFile, ENTITY_EXTENSION_CONST);
+    const checked = await checkedPairAsync(stubFile, solutionDir, fs7);
+    if (!checked.ok) {
+      results.push({
+        entityName: name,
+        diagnostics: [],
+        pairProblem: checked.problem
+      });
+      continue;
+    }
+    const { pair } = checked;
+    results.push({
+      entityName: pair.entityName,
+      resourceFile: pair.resourceFile,
+      diagnostics: validateEntity(pair.entity, {
+        siblingNames: await siblingNamesFor(solutionDir, pair.entityName, fs7)
+      })
+    });
+  }
+  return results;
+}
+function requireLocallyAuthored(resolved) {
+  if (isLocallyAuthored(resolved.entity)) {
+    return;
+  }
+  throw new InlineEntityError(`Entity '${resolved.entityName}' is a platform entity this solution references, not an inline one`, `It resolves to Data Fabric folder '${resolved.entity.FolderId}'. Change its schema with 'uip df entities update <id>' or in Data Fabric; the inline commands only author entities created locally.`, INLINE_ENTITY_ERROR_CODES.notLocallyAuthored);
+}
+async function inlineEntityUpdateAsync(projectName, entityName, update, options = {}) {
+  assertEntityTextInput(update);
+  const fs7 = fsOf();
+  const resolved = await resolveEntityAsync(projectName, entityName, options);
+  requireLocallyAuthored(resolved);
+  await requireEntityProjectAsync(resolved.projectDir, projectName, resolved.solutionDir, fs7);
+  const next = {
+    ...resolved.entity,
+    Fields: [...resolved.entity.Fields]
+  };
+  if (update.displayName !== undefined)
+    next.DisplayName = update.displayName;
+  if (update.description !== undefined)
+    next.Description = update.description;
+  const indexOfField = (name) => fieldIndexOf(next, name);
+  for (const remove of update.removeFields ?? []) {
+    const at = indexOfField(remove.name);
+    if (at < 0) {
+      throw new InlineEntityError(`Field '${remove.name}' is not on entity '${resolved.entityName}'`, `Fields: ${next.Fields.map((field) => field.Name).join(", ")}.`);
+    }
+    if (isSystemField(next.Fields[at])) {
+      throw new InlineEntityError(`Field '${remove.name}' is a system field and cannot be removed`, "Data Fabric owns Id, CreateTime, CreatedBy, UpdateTime and UpdatedBy on every entity.");
+    }
+    next.Fields.splice(at, 1);
+  }
+  for (const change of update.updateFields ?? []) {
+    const at = indexOfField(change.name);
+    if (at < 0) {
+      throw new InlineEntityError(`Field '${change.name}' is not on entity '${resolved.entityName}'`, `Fields: ${next.Fields.map((field) => field.Name).join(", ")}.`);
+    }
+    const current = next.Fields[at];
+    if (current === undefined || isSystemField(current)) {
+      throw new InlineEntityError(`Field '${change.name}' is a system field and cannot be changed`, "Data Fabric owns Id, CreateTime, CreatedBy, UpdateTime and UpdatedBy on every entity.");
+    }
+    const merged = (key, fallback) => (key in change) ? change[key] : fallback;
+    const currentType = sdkTypeOf(current);
+    const retyped = change.type !== undefined && change.type !== currentType;
+    const inherited = (key, fallback) => retyped ? merged(key, undefined) : merged(key, fallback);
+    next.Fields[at] = authorField({
+      name: current.Name,
+      type: merged("type", currentType),
+      displayName: merged("displayName", current.DisplayName),
+      description: merged("description", current.Description),
+      isRequired: merged("isRequired", current.IsRequired),
+      isUnique: merged("isUnique", current.IsUnique),
+      lengthLimit: inherited("lengthLimit", current.SqlType?.LengthLimit),
+      decimalPrecision: inherited("decimalPrecision", current.SqlType?.DecimalPrecision),
+      maxValue: inherited("maxValue", current.SqlType?.MaxValue),
+      minValue: inherited("minValue", current.SqlType?.MinValue),
+      defaultValue: merged("defaultValue", retyped && typeof current.DefaultValue === "boolean" ? String(current.DefaultValue) : current.DefaultValue)
+    }, {
+      defaultValueFromCaller: retyped || "defaultValue" in change
+    });
+    const rebuilt = next.Fields[at];
+    const previous = current;
+    for (const key of Object.keys(previous)) {
+      if (!(key in rebuilt)) {
+        rebuilt[key] = previous[key];
+      }
+    }
+    for (const preserved of PRESERVED_FIELD_PROPS) {
+      if (previous[preserved] !== undefined) {
+        rebuilt[preserved] = previous[preserved];
+      }
+    }
+  }
+  addAuthoredFields(next, update.addFields ?? [], resolved.entityName, "Field names are case-insensitive. Use updateFields to change the existing one.");
+  const diagnostics = validateEntity(next, {
+    siblingNames: await siblingNamesFor(resolved.solutionDir, resolved.entityName, fs7)
+  });
+  if (diagnostics.length > 0) {
+    throw new InlineEntityError(`The edit would leave entity '${resolved.entityName}' invalid, so nothing was written`, diagnostics.map((diagnostic) => `${diagnostic.code}: ${diagnostic.message}`).join(`
+`));
+  }
+  await fs7.writeFile(resolved.resourceFile, serialize(updateResourceSchema(resolved.resource, next)));
+  return { entity: next, resourceFile: resolved.resourceFile };
+}
+function fieldIndexOf(entity, name) {
+  return entity.Fields.findIndex((field) => typeof field?.Name === "string" && field.Name.toLowerCase() === name.toLowerCase());
+}
+function addAuthoredFields(next, fields, entityName, duplicateAdvice) {
+  for (const add of fields) {
+    const existing = next.Fields[fieldIndexOf(next, add.name)];
+    if (isSystemField(existing)) {
+      throw new InlineEntityError(`'${existing.Name}' is a system field on entity '${entityName}'`, "Data Fabric adds Id, CreateTime, CreatedBy, UpdateTime and UpdatedBy to every entity. Choose another name.");
+    }
+    if (existing !== undefined) {
+      throw new InlineEntityError(`Entity '${entityName}' already has a field named '${add.name}'`, duplicateAdvice);
+    }
+    next.Fields.push(authorField(add));
+  }
+}
+function authorNewEntity(entityName, definition) {
+  assertEntityTextInput(definition);
+  const next = createEntitySkeleton(entityName);
+  if (definition.displayName !== undefined) {
+    next.DisplayName = definition.displayName;
+  }
+  if (definition.description !== undefined) {
+    next.Description = definition.description;
+  }
+  addAuthoredFields(next, definition.addFields ?? [], entityName, "Field names are case-insensitive. Give each field a distinct name.");
+  const diagnostics = validateEntity(next, { siblingNames: [] });
+  if (diagnostics.length > 0) {
+    throw new InlineEntityError(`Cannot create entity '${entityName}'`, diagnostics.map((diagnostic) => `${diagnostic.code}: ${diagnostic.message}`).join(`
+`));
+  }
+  return next;
+}
+function sdkTypeOf(field) {
+  const pair = `${field.FieldDisplayType}:${field.SqlType.Name}`;
+  const known = {
+    "Basic:NVARCHAR": "STRING",
+    "Basic:DECIMAL": "DECIMAL",
+    "Basic:BIT": "BOOLEAN",
+    "Basic:DATE": "DATE",
+    "Basic:DATETIMEOFFSET": "DATETIME_WITH_TZ",
+    "Basic:MULTILINE": "MULTILINE_TEXT",
+    "Basic:MULTILINE_MAX": "MULTILINE_MAX",
+    "MultiLineText:MULTILINE": "MULTILINE_TEXT",
+    "MultiLineText:MULTILINE_MAX": "MULTILINE_MAX",
+    "AutoNumber:DECIMAL": "AUTO_NUMBER",
+    "File:UNIQUEIDENTIFIER": "FILE"
+  };
+  const type = known[pair];
+  if (type === undefined) {
+    throw new InlineEntityError(`Field type ${pair} cannot be edited by the inline commands`, "Only fields authored from the supported type list can be changed here. Edit this one in Data Fabric.");
+  }
+  return type;
+}
+async function inlineEntityAddAsync(projectName, entityName, options = {}, authored) {
+  requireAuthoredName(authored, entityName);
+  const fs7 = fsOf();
+  const { projectDir, solutionDir } = await resolveProjectAsync(projectName, options);
+  await requireEntityProjectAsync(projectDir, projectName, solutionDir, fs7);
+  const stubFile = entityStubPath(projectDir, entityName, fs7);
+  let exists = false;
+  try {
+    exists = await fs7.stat(stubFile) !== null;
+  } catch (error) {
+    if (!isMissingPathError(error)) {
+      throw error;
+    }
+    exists = false;
+  }
+  if (exists) {
+    throw new InlineEntityError(`Entity '${entityName}' already exists in project '${projectName}'`, `Edit it with 'uip df entities update ${entityName} --local'.`);
+  }
+  const document = authored ?? createEntitySkeleton(entityName);
+  const diagnostics = validateEntity(document, {
+    siblingNames: await collectSolutionEntityNames(solutionDir, fs7)
+  });
+  if (diagnostics.length > 0) {
+    throw new InlineEntityError(`Cannot create entity '${entityName}'`, diagnostics.map((diagnostic) => `${diagnostic.code}: ${diagnostic.message}`).join(`
+`));
+  }
+  const relativeResourcePath = entityResourcePath(entityName);
+  const resourceFile = fs7.path.join(solutionDir, ...relativeResourcePath.split("/"));
+  let resourceExists = false;
+  try {
+    resourceExists = await fs7.stat(resourceFile) !== null;
+  } catch (error) {
+    if (!isMissingPathError(error)) {
+      throw error;
+    }
+    resourceExists = false;
+  }
+  if (resourceExists) {
+    throw new InlineEntityError(`An entity definition for '${entityName}' already exists in this solution`, `'${relativeResourcePath}' is already present. Entity names are solution-wide unique — pick a different name, or edit the existing entity with 'uip df entities update ${entityName} --local'. If no .entity stub points at it (an interrupted create or delete leaves one behind), clear it with 'uip df entities delete ${entityName} --local --project-name ${projectName} --force --yes'.`);
+  }
+  await assertInsideSolutionAsync(resourceFile, solutionDir, fs7);
+  await assertInsideSolutionAsync(stubFile, solutionDir, fs7);
+  await fs7.mkdir(fs7.path.dirname(resourceFile));
+  await fs7.writeFile(resourceFile, serialize(wrapEntityJson(document)));
+  await fs7.writeFile(stubFile, serialize({ name: entityName, resourcePath: relativeResourcePath }));
+  return { entityFile: stubFile, resourceFile };
+}
+async function inlineEntityDeleteAsync(projectName, entityName, options = {}) {
+  const fs7 = fsOf();
+  const { projectDir, solutionDir } = await resolveProjectAsync(projectName, options);
+  const stubFile = entityStubPath(projectDir, entityName, fs7);
+  const checked = await checkedPairAsync(stubFile, solutionDir, fs7);
+  if (checked.ok) {
+    const { pair } = checked;
+    requireLocallyAuthored({
+      entityName: pair.entityName,
+      entity: pair.entity
+    });
+    await assertInsideSolutionAsync(pair.resourceFile, solutionDir, fs7);
+    const shared = await derivedResourceOwnershipProblem(pair.resourceFile, projectName, pair.entityName, solutionDir, fs7);
+    if (shared !== undefined) {
+      throw new InlineEntityError(`Refusing to delete entity '${pair.entityName}' from project '${projectName}'`, shared);
+    }
+    await fs7.rm(stubFile);
+    await fs7.rm(pair.resourceFile);
+    return { stubFile, resourceFile: pair.resourceFile };
+  }
+  if (!options.force) {
+    const stubMissing = !await pathOrLinkExistsAsync(stubFile, fs7);
+    const known = (await stubNamesAsync(projectDir, fs7)).map((name) => fs7.path.basename(name, ENTITY_EXTENSION_CONST));
+    throw new InlineEntityError(`Entity '${entityName}' is not usable in project '${projectName}': ${checked.problem}`, stubMissing ? known.length === 0 ? `Project '${projectName}' has no entities.` : `Entities in this project: ${known.join(", ")}.` : `Add --force to delete it anyway: that removes the stub and the definition resource for '${entityName}' without needing either to parse. It still refuses when it cannot prove the files are this project's to remove.`);
+  }
+  const derived = fs7.path.join(solutionDir, ...entityResourcePath(entityName).split("/"));
+  const stubIsLink = await isSymlinkEntryAsync(stubFile, fs7);
+  const stubExists = stubIsLink || await pathExistsAsync(stubFile, fs7);
+  const pointed = stubExists && !stubIsLink ? await stubResourcePathAsync(stubFile, entityName, solutionDir, fs7) : undefined;
+  const candidates = [];
+  if (pointed !== undefined && await pathOrLinkExistsAsync(pointed, fs7)) {
+    candidates.push(pointed);
+  }
+  if (await pathOrLinkExistsAsync(derived, fs7)) {
+    candidates.push(derived);
+  }
+  for (const candidate of candidates) {
+    await assertResourceRemovableAsync(candidate, projectName, entityName, solutionDir, fs7);
+  }
+  if (!stubExists && candidates.length === 0) {
+    throw new InlineEntityError(`Nothing to delete for entity '${entityName}' in project '${projectName}'`, `Neither '${stubFile}' nor a definition resource for '${entityName}' is on disk.`);
+  }
+  const removed = { forced: true };
+  if (stubExists) {
+    await fs7.rm(stubFile);
+    removed.stubFile = stubFile;
+  }
+  const removedPaths = [];
+  for (const candidate of candidates) {
+    if (await pathOrLinkExistsAsync(candidate, fs7)) {
+      await fs7.rm(candidate);
+      removedPaths.push(candidate);
+    }
+  }
+  removed.resourceFile = removedPaths[0];
+  return removed;
+}
+async function assertResourceRemovableAsync(resource, projectName, entityName, solutionDir, fs7) {
+  if (await isSymlinkEntryAsync(resource, fs7)) {
+    await assertInsideSolutionAsync(fs7.path.dirname(resource), solutionDir, fs7);
+    const blocked2 = await derivedResourceOwnershipProblem(resource, projectName, entityName, solutionDir, fs7, { ownersOnly: true });
+    if (blocked2 !== undefined) {
+      throw new InlineEntityError(`Refusing to delete the definition resource for '${entityName}'`, blocked2);
+    }
+    return;
+  }
+  await assertInsideSolutionAsync(resource, solutionDir, fs7);
+  const stat2 = await fs7.stat(resource);
+  if (stat2 !== null && !stat2.isFile()) {
+    throw new InlineEntityError(`Refusing to delete '${resource}'`, "It is a directory, not an entity definition file. Remove it by hand if it is not needed.");
+  }
+  const blocked = await derivedResourceOwnershipProblem(resource, projectName, entityName, solutionDir, fs7);
+  if (blocked !== undefined) {
+    throw new InlineEntityError(`Refusing to delete the definition resource for '${entityName}'`, blocked);
+  }
+}
+async function inlineEntityDeleteOrphanAsync(entityName, options = {}) {
+  const fs7 = fsOf();
+  const nameError = validateNameFormat(entityName, "entity");
+  if (nameError) {
+    throw new InlineEntityError(nameError.message, nameError.instructions);
+  }
+  const solutionDir = await solutionRootAsync(options);
+  const resource = fs7.path.join(solutionDir, ...entityResourcePath(entityName).split("/"));
+  if (!await pathOrLinkExistsAsync(resource, fs7)) {
+    throw new InlineEntityError(`Entity '${entityName}' not found`, `No project declares it and no definition resource for it is at '${resource}'.`, INLINE_ENTITY_ERROR_CODES.entityNotFound);
+  }
+  await assertResourceRemovableAsync(resource, "", entityName, solutionDir, fs7);
+  await fs7.rm(resource);
+  return { resourceFile: resource, forced: true };
+}
+async function pathOrLinkExistsAsync(path3, fs7) {
+  return await isSymlinkEntryAsync(path3, fs7) || await pathExistsAsync(path3, fs7);
+}
+async function pathExistsAsync(path3, fs7) {
+  try {
+    return await fs7.stat(path3) !== null;
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function stubResourcePathAsync(stubFile, entityName, solutionDir, fs7) {
+  let pointer;
+  try {
+    const raw = await fs7.readFile(stubFile, "utf-8");
+    if (raw === null)
+      return;
+    pointer = JSON.parse(raw).resourcePath;
+  } catch (error) {
+    if (isUnreadablePathError(error))
+      throw error;
+    return;
+  }
+  if (typeof pointer !== "string")
+    return;
+  const solutionRoot = fs7.path.resolve(solutionDir);
+  const resolved = fs7.path.resolve(solutionRoot, ...pointer.split("/"));
+  const boundary = resolved.charAt(solutionRoot.length);
+  if (!resolved.startsWith(solutionRoot) || boundary !== "/" && boundary !== "\\") {
+    return;
+  }
+  const canonicalTree = await canonicalPathAsync(entityTreeDir(solutionRoot, fs7), fs7);
+  const canonical = await canonicalPathAsync(resolved, fs7);
+  const parent = fs7.path.dirname(canonical);
+  const sameDir = parent.toLowerCase() === canonicalTree.toLowerCase();
+  const expected = `${entityName}.json`.toLowerCase();
+  if (!sameDir || fs7.path.basename(canonical).toLowerCase() !== expected) {
+    return;
+  }
+  let stat2 = null;
+  try {
+    stat2 = await fs7.stat(canonical);
+  } catch (error) {
+    if (!isMissingPathError(error))
+      throw error;
+  }
+  if (stat2 !== null && !stat2.isFile()) {
+    return;
+  }
+  return canonical;
+}
+function entityTreeDir(solutionRoot, fs7) {
+  return fs7.path.resolve(solutionRoot, "resources", SOLUTION_FOLDER, ...ENTITY_RESOURCE_DIR.split("/"));
+}
+async function derivedResourceOwnershipProblem(derived, projectName, entityName, solutionDir, fs7, options = {}) {
+  let owners;
+  try {
+    owners = await findProjectsOwningEntity(solutionDir, entityName, fs7);
+  } catch (error) {
+    return `Could not check whether another project still declares an entity named '${entityName}' (${error instanceof Error ? error.message : String(error)}), and the definition resource is shared by name across the solution. Fix access to the solution's project directories and retry.`;
+  }
+  const others = owners.filter((owner) => owner.projectName.toLowerCase() !== projectName.toLowerCase());
+  if (others.length > 0) {
+    return `'${others.map((owner) => owner.projectName).join("', '")}' still declare an entity named '${entityName}', and the definition resource is shared by name across the solution. Delete it from there instead, or remove those stubs first.`;
+  }
+  if (options.ownersOnly)
+    return;
+  let entity;
+  try {
+    const raw = await fs7.readFile(derived, "utf-8");
+    if (typeof raw !== "string")
+      return;
+    entity = unwrapResource(JSON.parse(raw));
+  } catch (error) {
+    if (isUnreadablePathError(error)) {
+      return `Could not read the definition resource '${derived}' (${messageOf(error)}), so whether it is safe to delete cannot be checked. Fix access to the file and retry.`;
+    }
+    return;
+  }
+  if (!isLocallyAuthored(entity)) {
+    return `It describes a platform entity this solution references, not one authored here — it resolves to Data Fabric folder '${entity.FolderId}'. Remove the reference with 'uip solution resources remove' instead; deleting the file drops the reference without recording it.`;
+  }
+  return;
+}
+export {
+  INLINE_ENTITY_ERROR_CODES,
+  InlineEntityError,
+  authorNewEntity,
+  inlineEntityAddAsync,
+  inlineEntityDeleteAsync,
+  inlineEntityDeleteOrphanAsync,
+  inlineEntityGetAsync,
+  inlineEntityListAllAsync,
+  inlineEntityListAsync,
+  inlineEntityUpdateAsync,
+  inlineEntityValidateAsync,
+  resolveOwningProjectAsync,
+  resolveProjectAsync,
+  solutionRootAsync
+};
+
+//# debugId=AA4817EB17331A5D64756E2164756E21