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

package/dist/index.js

@@ -1,11 +1,461 @@
+// ../../common/src/telemetry/pseudonymize.ts
+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
+]);
+
+// ../../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");
+
+// ../../common/src/telemetry/pii-redactor.ts
+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 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 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 MESSAGE_NAMES = new Set([
+  "message",
+  "errormessage",
+  "errmessage",
+  "error_message",
+  "msg",
+  "detail",
+  "details",
+  "reason",
+  "instructions",
+  "warning"
+]);
+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;
+}
+
+// ../../common/src/catch-error.ts
+var MAX_SERIALIZED_LENGTH = 500;
+var TRUNCATION_SUFFIX = "…(truncated)";
+var REDACTED = "[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) ? REDACTED : 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/pack/entity-project-tool.ts
 import {
   ProjectTool,
   ToolResult
 } from "@uipath/solutionpackager-tool-core";
 
+// 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";
+var ENTITY_VALIDATION_FAILED = "ENTITY_VALIDATION_FAILED";
+var PACK_DIAGNOSTIC_CODES = {
+  misplacedMainFile: "MISPLACED_MAIN_FILE",
+  noParentSolution: "NO_PARENT_SOLUTION",
+  solutionRootUnreadable: "SOLUTION_ROOT_UNREADABLE"
+};
+
+// 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, fs) {
+  const names = [];
+  let topLevel = [];
+  try {
+    topLevel = await fs.readdir(solutionDir);
+  } catch (error) {
+    if (!isMissingPath(error)) {
+      throw error;
+    }
+    return names;
+  }
+  for (const entry of topLevel) {
+    if (entry === "resources" || entry.startsWith(".")) {
+      continue;
+    }
+    const dir = fs.path.join(solutionDir, entry);
+    try {
+      const stat = await fs.stat(dir);
+      if (!stat?.isDirectory()) {
+        continue;
+      }
+      for (const file of await fs.readdir(dir)) {
+        if (file.endsWith(ENTITY_EXTENSION_CONST)) {
+          names.push(fs.path.basename(file, ENTITY_EXTENSION_CONST));
+        }
+      }
+    } catch (error) {
+      if (!isMissingPath(error)) {
+        throw error;
+      }
+    }
+  }
+  return names;
+}
+
+// ../../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;
+}
+
 // ../../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",
@@ -223,6 +673,16 @@ function findReservedNameError(name, kind) {
   }
   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."
+  };
+}
 
 // ../../../node_modules/@uipath/entity-modeler/dist/chunk-7VKIHCI7.js
 var SqlTypeName = {
@@ -250,7 +710,7 @@ var FieldDisplayType = {
   AutoNumber: "AutoNumber",
   MultiLineText: "MultiLineText"
 };
-var NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9]{2,99}$/;
+var DEFAULT_REFERENCE_TYPE = "ManyToOne";
 var CSHARP_RESERVED_WORDS = [
   "__arglist",
   "__makeref",
@@ -514,8 +974,158 @@ var GA_TYPE_PAIRS = [
   [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,
@@ -605,14 +1215,27 @@ var DIAGNOSTIC_CODES = {
   fieldTypeNotAllowed: "FIELD_TYPE_NOT_ALLOWED",
   nameReserved: "NAME_RESERVED",
   systemFieldMissing: "SYSTEM_FIELD_MISSING",
-  systemFieldModified: "SYSTEM_FIELD_MODIFIED"
+  systemFieldModified: "SYSTEM_FIELD_MODIFIED",
+  fieldsMalformed: "FIELDS_MALFORMED",
+  tooManyMultilineMax: "TOO_MANY_MULTILINE_MAX",
+  propertyTypeInvalid: "PROPERTY_TYPE_INVALID"
 };
 function validateEntity(entity, ctx) {
   const diagnostics = [];
-  if (!NAME_PATTERN.test(entity.Name)) {
+  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: `Entity name '${entity.Name}' must start with a letter and contain 3-100 letters or digits.`,
+      message: `${entityNameFormat.message}. ${entityNameFormat.instructions}`,
       severity: "error"
     });
   }
@@ -632,17 +1255,39 @@ function validateEntity(entity, ctx) {
       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 (!field.IsSystemField && !NAME_PATTERN.test(field.Name)) {
+    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: `Field name '${field.Name}' must start with a letter and contain 3-100 letters or digits.`,
+        message: `${fieldNameFormat.message}. ${fieldNameFormat.instructions}`,
         severity: "error",
         fieldName: field.Name
       });
     }
-    if (!field.IsSystemField) {
+    if (!isSystem) {
       const reservedFieldName = findReservedNameError(field.Name, "field");
       if (reservedFieldName) {
         diagnostics.push({
@@ -654,6 +1299,14 @@ function validateEntity(entity, ctx) {
       }
     }
     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({
@@ -665,16 +1318,25 @@ function validateEntity(entity, ctx) {
     } else {
       seenFieldNames.set(fieldNameLower, field.Name);
     }
-    if (!field.IsSystemField && !ALLOWED_TYPE_PAIRS.has(`${field.FieldDisplayType}:${field.SqlType.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}).`,
+        message: `Field '${field.Name}' uses an unsupported type combination ` + `(${field.FieldDisplayType} / ${field.SqlType?.Name}).`,
         severity: "error",
         fieldName: field.Name
       });
     }
   }
-  diagnostics.push(...validateSystemFields(entity));
+  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([
@@ -693,10 +1355,10 @@ function isUnmodifiedSystemField(template, actual) {
   }
   return Object.keys(actual).every((key) => (key in template) || SERVER_ASSIGNED_FIELD_PROPS.has(key));
 }
-function validateSystemFields(entity) {
+function validateSystemFields(entity, usableFields) {
   const diagnostics = [];
   for (const template of SYSTEM_FIELD_TEMPLATES) {
-    const actual = entity.Fields.find((field) => field.Name === template.Name);
+    const actual = usableFields.find((field) => field.Name === template.Name);
     if (!actual) {
       diagnostics.push({
         code: DIAGNOSTIC_CODES.systemFieldMissing,
@@ -717,14 +1379,75 @@ function validateSystemFields(entity) {
   }
   return diagnostics;
 }
-
-// src/pack/constants.ts
-var ENTITY_EXTENSION_CONST = ".entity";
-var ENTITY_VALIDATION_FAILED = "ENTITY_VALIDATION_FAILED";
-var PACK_DIAGNOSTIC_CODES = {
-  misplacedMainFile: "MISPLACED_MAIN_FILE",
-  noParentSolution: "NO_PARENT_SOLUTION"
-};
+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/resource/unified-resource-file.ts
 var ENTITY_RESOURCE_KIND = "entity";
@@ -732,8 +1455,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
@@ -891,14 +1615,16 @@ function failure(code, message) {
 }
 async function findSolutionRoot(startDir, fs) {
   let dir = fs.path.resolve(startDir);
+  let unreadable;
   for (;; ) {
-    let entries = [];
-    try {
-      entries = await fs.readdir(dir);
-    } catch {
-      entries = [];
+    const [error, entries] = await catchError(fs.readdir(dir));
+    if (error && isUnreadablePathError(error)) {
+      unreadable ??= error;
     }
-    if (entries.some((name) => name.endsWith(".uipx"))) {
+    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 = fs.path.dirname(dir);
@@ -938,8 +1664,16 @@ class EntityProjectTool extends ProjectTool {
         message: `'${foreign}' is a Flow main file inside an Entity project — move it to a Flow project.`
       });
     }
-    const solutionDir = await findSolutionRoot(projectPath, fs);
-    if (solutionDir === undefined) {
+    const [rootError, solutionDir] = await catchError(findSolutionRoot(projectPath, fs));
+    if (rootError) {
+      if (stubs.length > 0) {
+        diagnostics.push({
+          file: projectPath,
+          code: PACK_DIAGNOSTIC_CODES.solutionRootUnreadable,
+          message: rootError.message
+        });
+      }
+    } else if (solutionDir === undefined) {
       if (stubs.length > 0) {
         diagnostics.push({
           file: projectPath,
@@ -995,51 +1729,57 @@ function compareCodeUnits(left, right) {
   }
   return left > right ? 1 : 0;
 }
-function withoutOneOccurrence(names, name) {
-  const siblings = [...names];
-  const self = siblings.indexOf(name);
-  if (self >= 0) {
-    siblings.splice(self, 1);
+// src/pack/entity-tool-factory.ts
+class EntityToolFactory {
+  supportedTypes = ["Entity"];
+  async createAsync(logger, fileSystem) {
+    return new EntityProjectTool(fileSystem, logger);
   }
-  return siblings;
 }
-async function collectSolutionEntityNames(solutionDir, fs) {
-  const names = [];
-  let topLevel = [];
+// src/resource/local-entities.ts
+async function readSolutionInlineEntities(fs, flowFilePath) {
+  const found = new Map;
+  const solutionDir = await findSolutionRoot(fs.path.dirname(fs.path.resolve(flowFilePath)), fs);
+  if (solutionDir === undefined) {
+    return found;
+  }
+  const dir = fs.path.join(solutionDir, "resources", SOLUTION_FOLDER, ...ENTITY_RESOURCE_DIR.split("/"));
+  let files = [];
   try {
-    topLevel = await fs.readdir(solutionDir);
+    files = await fs.readdir(dir);
   } catch {
-    return names;
+    return found;
   }
-  for (const entry of topLevel) {
-    if (entry === "resources" || entry.startsWith(".")) {
+  for (const file of files) {
+    if (!file.endsWith(".json")) {
       continue;
     }
-    const dir = fs.path.join(solutionDir, entry);
     try {
-      const stat = await fs.stat(dir);
-      if (!stat?.isDirectory()) {
+      const raw = await fs.readFile(fs.path.join(dir, file), "utf-8");
+      if (raw === null) {
         continue;
       }
-      for (const file of await fs.readdir(dir)) {
-        if (file.endsWith(ENTITY_EXTENSION_CONST)) {
-          names.push(fs.path.basename(file, ENTITY_EXTENSION_CONST));
-        }
+      const parsed = JSON.parse(raw);
+      const entity = unwrapResource(parsed);
+      if (!isLocallyAuthored(entity)) {
+        continue;
       }
+      const resourceKey = typeof parsed.resource?.key === "string" && parsed.resource.key !== "" ? parsed.resource.key : entity.Id;
+      found.set(entity.Name.toLowerCase(), {
+        name: entity.Name,
+        resourceKey,
+        folderId: entity.FolderId
+      });
     } catch {}
   }
-  return names;
-}
-// src/pack/entity-tool-factory.ts
-class EntityToolFactory {
-  supportedTypes = ["Entity"];
-  async createAsync(logger, fileSystem) {
-    return new EntityProjectTool(fileSystem, logger);
-  }
+  return found;
 }
 export {
+  AUTHORABLE_FIELD_TYPES,
+  AuthoredFieldError,
   DIAGNOSTIC_CODES,
   ENTITY_RESOURCE_API_VERSION,
+  ENTITY_RESOURCE_DIR,
   ENTITY_RESOURCE_DOC_VERSION,
   ENTITY_RESOURCE_KIND,
   ENTITY_RESOURCE_TYPE,
@@ -1049,9 +1789,13 @@ export {
   EntityToolFactory,
   SOLUTION_FOLDER,
   SYSTEM_FIELD_TEMPLATES,
+  UNASSIGNED_FOLDER_ID,
+  authorField,
   createEntitySkeleton,
   entityResourcePath,
   findSolutionRoot,
+  isLocallyAuthored,
+  readSolutionInlineEntities,
   serialize,
   serializeEntityJson,
   unwrapResource,
@@ -1061,4 +1805,4 @@ export {
   wrapEntityJson
 };
 
-//# debugId=6EFF0E08D007F24864756E2164756E21
+//# debugId=B83BCECF16611A3364756E2164756E21