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

package/dist/init.js

@@ -7822,6 +7822,16 @@ class NodeFileSystem {
   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);
@@ -8529,7 +8539,7 @@ function setGlobalLogFilePath(path3) {
 function getGlobalLogFilePath() {
   return logFilePathSlot.get("");
 }
-var DEFAULT_LOG_LEVEL = 3 /* ERROR */;
+var DEFAULT_LOG_LEVEL = 2 /* WARN */;
 
 class SimpleLogger {
   __brand = "SimpleLogger";
@@ -8796,7 +8806,9 @@ var ErrorDimensions = {
   Result: "Result",
   ErrorCode: "ErrorCode",
   Retry: "Retry",
-  ErrorMessage: "ErrorMessage"
+  ErrorMessage: "ErrorMessage",
+  HttpStatus: "HttpStatus",
+  UpstreamErrorCode: "UpstreamErrorCode"
 };
 var AuthDimensions = {
   AuthenticationMethod: "AuthenticationMethod",
@@ -9778,7 +9790,9 @@ var CLI_ERROR_CODES = [
   "timeout",
   "server_error",
   "method_not_allowed",
+  "not_supported",
   "configuration_error",
+  "execution_failed",
   "unknown_error"
 ];
 var RETRY_HINTS = [
@@ -10735,7 +10749,9 @@ var OutputFormatter;
         [ErrorDimensions.Result]: data.Result,
         [ErrorDimensions.ErrorCode]: data.ErrorCode,
         [ErrorDimensions.Retry]: data.Retry,
-        [ErrorDimensions.ErrorMessage]: data.Message
+        [ErrorDimensions.ErrorMessage]: data.Message,
+        [ErrorDimensions.HttpStatus]: data.Context?.httpStatus?.toString(),
+        [ErrorDimensions.UpstreamErrorCode]: data.Context?.errorCode
       });
     }
     logOutput(normalizeOutputKeys(envelope), getOutputFormat());
@@ -11270,8 +11286,110 @@ var guardInstalledSlot = singleton("ConsoleGuardInstalled");
 var savedOriginalsSlot = singleton("ConsoleGuardOriginals");
 // ../../common/src/constants.ts
 var DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
+// ../../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 type2 = rec.type;
+    if (typeof type2 !== "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[type2];
+      if (range === undefined) {
+        return {
+          message: `Field '${fieldName}' of type '${type2}' 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 '${type2}'`,
+          instructions: `'lengthLimit' on '${type2}' 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 (type2 !== "DECIMAL" && type2 !== "AUTO_NUMBER") {
+        const which = rec.maxValue !== undefined ? "maxValue" : "minValue";
+        return {
+          message: `Field '${fieldName}' of type '${type2}' 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 (type2 !== "DECIMAL" && type2 !== "AUTO_NUMBER") {
+        return {
+          message: `Field '${fieldName}' of type '${type2}' 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;
+}
 // ../../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",
@@ -11468,6 +11586,37 @@ var RESERVED_KEYWORDS_LOWER = new Set([
   "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."
+  };
+}
 // ../../common/src/host-global-options.ts
 var HOST_GLOBAL_OPTIONS_WITH_VALUE = [
   "--output",
@@ -11638,6 +11787,10 @@ function installRequestHeaderForwarding(BaseApiClass, patchKey, forward) {
 function installSdkUserAgentHeader(BaseApiClass, userAgent) {
   installRequestHeaderForwarding(BaseApiClass, userAgentPatchKey(userAgent), (headers) => addSdkUserAgentHeader(headers, userAgent));
 }
+// ../../common/src/shell-quote.ts
+function quoteForShell(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
 // ../../common/src/solution-project-types.ts
 var LIBRARY_NOT_A_PROJECT = "A library cannot be a project inside a solution — it is a reusable .nupkg that other projects consume as a NuGet dependency, not a deployable unit. Build and publish it on its own ('uip rpa pack <project-dir> <output-path>', then 'uip or libraries upload --file <nupkg-path>'), and reference it from a project's dependencies. To make the published library part of this solution, add it as a resource instead: 'uip solution resources add --source remote --kind Library --name <library-name>'.";
 function unsupportedSolutionProjectType(projectType) {
@@ -11650,296 +11803,6 @@ function unsupportedSolutionProjectType(projectType) {
 var shippedKeysSlot = singleton("ShipSucceededDedupeKeys");
 // ../../common/src/tool-provider.ts
 var factorySlot = singleton("PackagerFactoryProvider");
-// ../../../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 NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9]{2,99}$/;
-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}`));
 // ../../solution-sdk/generated/src/runtime.ts
 var BASE_PATH = "https://alpha.uipath.com/uipattycyrhx/abizon_1/automationsolutions_".replace(/\/+$/, "");
 
@@ -12164,7 +12027,7 @@ var package_default = {
   name: "@uipath/solution-sdk",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.204.0",
+  version: "1.205.0-preview.258",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -12193,6 +12056,14 @@ var package_default = {
     "./auth": {
       types: "./dist/src/solution-auth.d.ts",
       default: "./dist/solution-auth.js"
+    },
+    "./deployments": {
+      types: "./dist/src/deployment-search.d.ts",
+      default: "./dist/deployment-search.js"
+    },
+    "./packages": {
+      types: "./dist/src/package-search.d.ts",
+      default: "./dist/package-search.js"
     }
   },
   bin: {
@@ -12203,7 +12074,7 @@ var package_default = {
   ],
   private: false,
   scripts: {
-    build: "bun build ./src/index.ts ./src/resources/index.ts ./src/solution-auth.ts --outdir dist --format esm --target node --splitting --sourcemap=linked && bun build ./src/scripts/generate-sdk.ts --outdir dist/scripts --format esm --target node --sourcemap=linked && tsc -p tsconfig.build.json --noCheck",
+    build: "bun build ./src/index.ts ./src/resources/index.ts ./src/solution-auth.ts ./src/deployment-search.ts ./src/package-search.ts --outdir dist --format esm --target node --splitting --sourcemap=linked && bun build ./src/scripts/generate-sdk.ts --outdir dist/scripts --format esm --target node --sourcemap=linked && tsc -p tsconfig.build.json --noCheck",
     generate: "bun run src/scripts/generate-sdk.ts",
     lint: "biome check .",
     test: "vitest run",
@@ -12215,7 +12086,8 @@ var package_default = {
     "@uipath/common": "workspace:*",
     "@uipath/filesystem": "workspace:*",
     "@uipath/orchestrator-sdk": "workspace:*",
-    "@uipath/resource-builder-sdk": "2025.11.0-alpha6004-4107",
+    "@uipath/pipelines-sdk": "workspace:*",
+    "@uipath/resource-builder-sdk": "2025.11.0-alpha6584-4367",
     "@uipath/solutionpackager-tool-core": "workspace:*",
     "@uipath/studioweb-sdk": "workspace:*",
     "@types/node": "^25.5.2",
@@ -12800,7 +12672,7 @@ function buildRegistrationSuccessInstructions(solutionDir) {
   return [
     "The project is listed in the parent solution manifest.",
     "Packing or uploading the solution will sync solution resources automatically.",
-    `To sync resources before packaging, run 'uip solution resources refresh --solution-folder "${solutionDir}"'.`
+    `To sync resources before packaging, run: uip solution resources refresh --solution-folder ${quoteForShell(solutionDir)}`
   ].join(`
 `);
 }
@@ -12839,11 +12711,56 @@ var DEFAULT_EXCLUDED_DIR_NAMES = new Set([
   "__pycache__",
   ".git",
   ".local",
-  ".flow-sdk"
+  ".flow-sdk",
+  ".flow-debug"
 ]);
 // ../../solution-sdk/src/project-debug-status.ts
 var SUCCEEDED = "creationsucceeded";
 var TERMINAL = new Set([SUCCEEDED, "creationfailed", "validationfailed"]);
+// 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";
 
@@ -12853,8 +12770,9 @@ 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/native/${entityName}.json`;
+  return `resources/${SOLUTION_FOLDER}/${ENTITY_RESOURCE_DIR}/${entityName}.json`;
 }
 
 // src/resource/resource-io.ts
@@ -12865,6 +12783,15 @@ function serialize(value) {
 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,
@@ -12889,161 +12816,1029 @@ function wrapEntityJson(entity) {
     }
   };
 }
-
-// src/schema/create-entity-skeleton.ts
-var UNASSIGNED_FOLDER_ID = "99999999-9999-9999-9999-999999999999";
-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
-  };
-}
-
-// src/init/entity-init-service.ts
-var VALID_PROJECT_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
-async function entityInitAsync(name, options) {
-  if (!VALID_PROJECT_NAME_REGEX.test(name)) {
-    throw new Error(`Invalid project name "${name}". Name can only contain letters, numbers, underscores (_), and hyphens (-).`);
+function unwrapResource(file) {
+  if (typeof file !== "object" || file === null || Array.isArray(file)) {
+    throw new EntityResourceError("NotAnObject", "Resource file is not a JSON object.");
   }
-  const entityName = options.firstEntityName;
-  if (!NAME_PATTERN.test(entityName)) {
-    throw new Error(`Invalid entity name "${entityName}". Entity names start with a letter and contain 3-100 letters or digits.`);
+  const resource = file.resource;
+  if (typeof resource !== "object" || resource === null) {
+    throw new EntityResourceError("MissingResource", "Resource file has no 'resource' object.");
   }
-  const fs7 = getFileSystem();
-  const solutionFile = await resolveSolutionFileAsync(options);
-  const { projectDir, autoCreatedSolution } = solutionFile ? { projectDir: fs7.path.join(fs7.path.dirname(solutionFile), name) } : await prepareProjectLocation(fs7, fs7.path.resolve(requireCwd(options), name), name, {});
-  const [statError, stat2] = await catchError(fs7.stat(projectDir));
-  if (statError && !isMissingPathError(statError)) {
-    throw statError;
+  if (resource.kind !== ENTITY_RESOURCE_KIND) {
+    throw new EntityResourceError("NotAnEntityResource", `Resource kind is '${String(resource.kind)}', expected '${ENTITY_RESOURCE_KIND}'.`);
   }
-  const projectDirExisted = !statError && stat2 !== null;
-  if (projectDirExisted && !options.force) {
-    const existingEntries = await fs7.readdir(projectDir);
-    if (existingEntries.length > 0) {
-      throw new Error(`Directory "${name}" already exists and is not empty. Use --force to overwrite.`);
-    }
+  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.");
   }
-  let registered;
-  const rollback = async () => {
-    if (registered) {
-      await unregisterProject(registered);
-    }
-    if (!projectDirExisted) {
-      await catchError(fs7.rm(projectDir));
-    }
-  };
   try {
-    await fs7.mkdir(projectDir);
-    await fs7.writeFile(fs7.path.join(projectDir, "project.uiproj"), serialize({ Name: name, ProjectType: "Entity" }));
-    const relativeResourcePath = entityResourcePath(entityName);
-    const entityFile = fs7.path.join(projectDir, `${entityName}${ENTITY_EXTENSION_CONST}`);
-    await fs7.writeFile(entityFile, serialize({ name: entityName, resourcePath: relativeResourcePath }));
-    const registration = await tryRegisterProjectInParentSolution(fs7, projectDir, {});
-    if (registration.Status === "Registered" && registration.Solution && registration.ProjectId) {
-      registered = {
-        solutionFile: registration.Solution,
-        projectId: registration.ProjectId
-      };
-    }
-    if (registration.Status !== "Registered" && registration.Status !== "AlreadyRegistered" || !registration.Solution) {
-      if (solutionFile && registration.Status === "Skipped") {
-        throw new Error(`Entity project "${name}" could not be registered in '${solutionFile}': ` + `${registration.Instructions ?? registration.Message ?? "registration was skipped"}. ` + "A solution folder containing more than one .uipx is not supported yet — " + "register the project with 'uip solution projects add' instead.");
-      }
-      throw new Error(`Entity project "${name}" requires a parent solution (registration status: ${registration.Status}). ` + "Run inside a solution directory, or create one first with 'uip solution init'.");
-    }
-    const solutionDir = fs7.path.dirname(registration.Solution);
-    const resourceFile = fs7.path.join(solutionDir, ...relativeResourcePath.split("/"));
-    await fs7.mkdir(fs7.path.dirname(resourceFile));
-    await fs7.writeFile(resourceFile, serialize(wrapEntityJson(createEntitySkeleton(entityName))));
-    return {
-      projectName: name,
-      projectDir,
-      entityFile,
-      resourceFile,
-      registration,
-      autoCreatedSolution
-    };
-  } catch (error) {
-    await rollback();
-    throw error;
+    return JSON.parse(spec.resourceJson);
+  } catch {
+    throw new EntityResourceError("ResourceJsonUnparsable", "'spec.resourceJson' is not valid JSON.");
   }
 }
-function requireCwd(options) {
-  if (!options.cwd) {
-    throw new Error("Either 'cwd' or 'uipxPath' is required: without one there is no base " + "directory to create the project in.");
+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
+      }
+    }
+  };
+}
+
+// ../../../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/init/entity-init-service.ts
+var VALID_PROJECT_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+async function entityInitAsync(name, options) {
+  if (!VALID_PROJECT_NAME_REGEX.test(name)) {
+    throw new Error(`Invalid project name "${name}". Name can only contain letters, numbers, underscores (_), and hyphens (-).`);
+  }
+  const entityName = options.firstEntityName;
+  requireAuthoredName(options.firstEntity, entityName);
+  const nameError = validateNameFormat(entityName, "entity");
+  if (nameError) {
+    throw new Error(`${nameError.message}. ${nameError.instructions}`);
+  }
+  const fs7 = getFileSystem();
+  const solutionFile = await resolveSolutionFileAsync(options);
+  const { projectDir, autoCreatedSolution } = solutionFile ? { projectDir: fs7.path.join(fs7.path.dirname(solutionFile), name) } : await prepareProjectLocation(fs7, fs7.path.resolve(requireCwd(options), name), name, {});
+  const [statError, stat2] = await catchError(fs7.stat(projectDir));
+  if (statError && !isMissingPathError(statError)) {
+    throw statError;
+  }
+  const projectDirExisted = !statError && stat2 !== null;
+  if (await isSymlinkEntryAsync(projectDir, fs7)) {
+    throw new Error(`Directory "${name}" is a link, not a project directory in the solution. ` + "Replace the link with the directory itself, or pick a different name.");
+  }
+  if (projectDirExisted && !options.force) {
+    const existingEntries = await fs7.readdir(projectDir);
+    if (existingEntries.length > 0) {
+      throw new Error(`Directory "${name}" already exists and is not empty. Use --force to overwrite.`);
+    }
+  }
+  let registered;
+  const created = [];
+  const writeTracked = async (path3, content) => {
+    if (await isSymlinkEntryAsync(path3, fs7)) {
+      throw new Error(`'${path3}' is a symbolic link. Entity project files must be real files; replace the link with the file itself.`);
+    }
+    const [readError, previous] = await catchError(fs7.readFile(path3, "utf-8"));
+    if (readError && !isMissingPathError(readError))
+      throw readError;
+    created.push({
+      path: path3,
+      previous: typeof previous === "string" ? previous : undefined
+    });
+    await fs7.writeFile(path3, content);
+  };
+  const rollback = async () => {
+    if (registered) {
+      await unregisterProject(registered);
+    }
+    for (const { path: path3, previous } of [...created].reverse()) {
+      const [undoError] = await catchError(previous === undefined ? fs7.rm(path3) : fs7.writeFile(path3, previous));
+      if (undoError) {
+        await reportUndoFailureAsync(path3, previous, undoError);
+      }
+    }
+    if (!projectDirExisted) {
+      await catchError(fs7.rm(projectDir));
+    }
+  };
+  try {
+    await fs7.mkdir(projectDir);
+    const projectFile = fs7.path.join(projectDir, "project.uiproj");
+    await writeTracked(projectFile, serialize({ Name: name, ProjectType: "Entity" }));
+    const relativeResourcePath = entityResourcePath(entityName);
+    const entityFile = fs7.path.join(projectDir, `${entityName}${ENTITY_EXTENSION_CONST}`);
+    await writeTracked(entityFile, serialize({ name: entityName, resourcePath: relativeResourcePath }));
+    const registration = await tryRegisterProjectInParentSolution(fs7, projectDir, {});
+    if (registration.Status === "Registered" && registration.Solution && registration.ProjectId) {
+      registered = {
+        solutionFile: registration.Solution,
+        projectId: registration.ProjectId
+      };
+    }
+    if (registration.Status !== "Registered" && registration.Status !== "AlreadyRegistered" || !registration.Solution) {
+      if (solutionFile && registration.Status === "Skipped") {
+        throw new Error(`Entity project "${name}" could not be registered in '${solutionFile}': ` + `${registration.Instructions ?? registration.Message ?? "registration was skipped"}. ` + "A solution folder containing more than one .uipx is not supported yet — " + "register the project with 'uip solution projects add' instead.");
+      }
+      throw new Error(`Entity project "${name}" requires a parent solution (registration status: ${registration.Status}). ` + "Run inside a solution directory, or create one first with 'uip solution init'.");
+    }
+    const solutionDir = fs7.path.dirname(registration.Solution);
+    const resourceFile = fs7.path.join(solutionDir, ...relativeResourcePath.split("/"));
+    const document = options.firstEntity ?? createEntitySkeleton(entityName);
+    const diagnostics = validateEntity(document, {
+      siblingNames: await siblingNamesFor(solutionDir, entityName, fs7)
+    });
+    if (diagnostics.length > 0) {
+      throw new Error(`Cannot create entity "${entityName}": ${diagnostics.map((diagnostic) => `${diagnostic.code}: ${diagnostic.message}`).join("; ")}`);
+    }
+    if (await fs7.exists(resourceFile)) {
+      throw new Error(`An entity definition for "${entityName}" already exists in this solution ` + `('${relativeResourcePath}'). Entity names are solution-wide unique — ` + "pick a different name, or edit the existing entity with 'uip df entities update <Name> --local'.");
+    }
+    const destination = await resolvesInsideAsync(resourceFile, solutionDir, fs7);
+    if (!destination.inside) {
+      throw new Error(`The entity definition path '${relativeResourcePath}' resolves outside the solution, to '${destination.resolved}'. ` + `Entity definitions must live inside the solution at '${destination.root}'; replace the link with the directory itself.`);
+    }
+    await fs7.mkdir(fs7.path.dirname(resourceFile));
+    await writeTracked(resourceFile, serialize(wrapEntityJson(document)));
+    return {
+      projectName: name,
+      projectDir,
+      entityFile,
+      resourceFile,
+      registration,
+      autoCreatedSolution
+    };
+  } catch (error) {
+    await rollback();
+    throw error;
+  }
+}
+async function reportUndoFailureAsync(path3, previous, undoError) {
+  const fs7 = getFileSystem();
+  if (previous !== undefined) {
+    const [readError, now] = await catchError(fs7.readFile(path3, "utf-8"));
+    if (readError) {
+      logger.warn(`Could not restore '${path3}' after a failed --force (${undoError.message}), nor read it to check (${readError.message}). Check its content before retrying.`);
+    } else if (now !== previous) {
+      logger.warn(`Could not restore '${path3}' after a failed --force: ${undoError.message}. ` + "Its previous content was not written back; recover it from version control or a backup.");
+    }
+    return;
+  }
+  const [statError, stat2] = await catchError(fs7.stat(path3));
+  if (statError || stat2 !== null) {
+    logger.warn(`Could not remove '${path3}', written by the failed run: ${undoError.message}. Delete it before retrying.`);
+  }
+}
+function requireCwd(options) {
+  if (!options.cwd) {
+    throw new Error("Either 'cwd' or 'uipxPath' is required: without one there is no base " + "directory to create the project in.");
   }
   return options.cwd;
 }
@@ -13072,9 +13867,6 @@ async function resolveSolutionFileAsync(options) {
   }
   return resolved;
 }
-function isMissingPathError(error) {
-  return "code" in error && (error.code === "ENOENT" || error.code === "PathNotFound");
-}
 async function unregisterProject(registered) {
   const { solutionFile, projectId } = registered;
   const fs7 = getFileSystem();
@@ -13093,4 +13885,4 @@ export {
   entityInitAsync
 };
 
-//# debugId=A0EB17AD660B9F7364756E2164756E21
+//# debugId=3E83943EDBFF213264756E2164756E21