@uipath/flow-tool 1.204.0 → 1.205.0-preview.258

package/dist/packager-tool-4x7tzvv0.js

@@ -0,0 +1,1176 @@
+import {
+  ProjectTool,
+  ToolResult
+} from "./packager-tool-pacrqxv2.js";
+import {
+  MAX_MULTILINE_MAX_FIELDS,
+  catchError,
+  findInvalidFieldConstraints,
+  findReservedNameError,
+  validateNameFormat
+} from "./packager-tool-t7ahhaer.js";
+
+// ../packager/packager-tool-datafabric/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);
+}
+
+// ../packager/packager-tool-datafabric/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"
+};
+
+// ../packager/packager-tool-datafabric/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;
+}
+
+// ../../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}`));
+// ../packager/packager-tool-datafabric/src/sort-names.ts
+function byName(a, b) {
+  return a.localeCompare(b, "en");
+}
+
+// ../packager/packager-tool-datafabric/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
+  };
+}
+
+// ../packager/packager-tool-datafabric/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
+  };
+}
+
+// ../packager/packager-tool-datafabric/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));
+}
+
+// ../packager/packager-tool-datafabric/src/resource/unified-resource-file.ts
+var ENTITY_RESOURCE_KIND = "entity";
+var ENTITY_RESOURCE_TYPE = "native";
+var ENTITY_RESOURCE_API_VERSION = "dataservice.uipath.com/v2";
+var ENTITY_RESOURCE_DOC_VERSION = "1.0.0";
+var SOLUTION_FOLDER = "solution_folder";
+var ENTITY_RESOURCE_DIR = `${ENTITY_RESOURCE_KIND}/${ENTITY_RESOURCE_TYPE}`;
+function entityResourcePath(entityName) {
+  return `resources/${SOLUTION_FOLDER}/${ENTITY_RESOURCE_DIR}/${entityName}.json`;
+}
+
+// ../packager/packager-tool-datafabric/src/resource/resource-io.ts
+function serialize(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function serializeEntityJson(entity) {
+  return JSON.stringify(entity);
+}
+
+class EntityResourceError extends Error {
+  failure;
+  constructor(failure, message) {
+    super(message);
+    this.failure = failure;
+    this.name = "EntityResourceError";
+  }
+}
+function wrapEntityJson(entity) {
+  return {
+    docVersion: ENTITY_RESOURCE_DOC_VERSION,
+    resource: {
+      name: entity.Name,
+      kind: ENTITY_RESOURCE_KIND,
+      type: ENTITY_RESOURCE_TYPE,
+      apiVersion: ENTITY_RESOURCE_API_VERSION,
+      isOverridable: true,
+      dependencies: [],
+      runtimeDependencies: [],
+      folders: [{ fullyQualifiedName: SOLUTION_FOLDER }],
+      spec: {
+        resourceJson: serializeEntityJson(entity),
+        name: entity.Name,
+        displayName: entity.DisplayName,
+        description: entity.Description
+      },
+      locks: [],
+      key: entity.Id,
+      files: []
+    }
+  };
+}
+function unwrapResource(file) {
+  if (typeof file !== "object" || file === null || Array.isArray(file)) {
+    throw new EntityResourceError("NotAnObject", "Resource file is not a JSON object.");
+  }
+  const resource = file.resource;
+  if (typeof resource !== "object" || resource === null) {
+    throw new EntityResourceError("MissingResource", "Resource file has no 'resource' object.");
+  }
+  if (resource.kind !== ENTITY_RESOURCE_KIND) {
+    throw new EntityResourceError("NotAnEntityResource", `Resource kind is '${String(resource.kind)}', expected '${ENTITY_RESOURCE_KIND}'.`);
+  }
+  const spec = resource.spec;
+  if (typeof spec !== "object" || spec === null || typeof spec.resourceJson !== "string") {
+    throw new EntityResourceError("MissingSpec", "Resource file has no 'spec.resourceJson' string.");
+  }
+  try {
+    return JSON.parse(spec.resourceJson);
+  } catch {
+    throw new EntityResourceError("ResourceJsonUnparsable", "'spec.resourceJson' is not valid JSON.");
+  }
+}
+function updateResourceSchema(file, entity) {
+  return {
+    ...file,
+    resource: {
+      ...file.resource,
+      name: entity.Name,
+      spec: {
+        ...file.resource.spec,
+        resourceJson: serializeEntityJson(entity),
+        name: entity.Name,
+        displayName: entity.DisplayName,
+        description: entity.Description
+      }
+    }
+  };
+}
+
+// ../packager/packager-tool-datafabric/src/pack/verify-pair.ts
+async function verifyPair(stubFile, solutionDir, fs) {
+  const parsedStub = await readStub(stubFile, fs);
+  if ("failure" in parsedStub) {
+    return { ok: false, failure: parsedStub.failure };
+  }
+  const stub = parsedStub.stub;
+  const baseName = fs.path.basename(stubFile, ENTITY_EXTENSION_CONST);
+  if (baseName !== stub.name) {
+    return fail("StubFileNameMismatch", `Stub file '${baseName}${ENTITY_EXTENSION_CONST}' names entity '${stub.name}' — the filename and the entity name must match.`);
+  }
+  const solutionRoot = fs.path.resolve(solutionDir);
+  const resourceFile = fs.path.resolve(solutionRoot, ...stub.resourcePath.split("/"));
+  const boundary = resourceFile.charAt(solutionRoot.length);
+  if (!resourceFile.startsWith(solutionRoot) || boundary !== "/" && boundary !== "\\") {
+    return fail("ResourcePathEscapes", `'${stub.name}': resourcePath '${stub.resourcePath}' points outside the solution.`);
+  }
+  const parsedResource = await readResource(resourceFile, stub.name, stub.resourcePath, fs);
+  if ("failure" in parsedResource) {
+    return { ok: false, failure: parsedResource.failure };
+  }
+  const resourceRaw = parsedResource.raw;
+  let entity;
+  try {
+    entity = unwrapResource(resourceRaw);
+  } catch (error) {
+    const detail = error instanceof EntityResourceError ? ` (${error.failure})` : "";
+    return fail("ResourceInvalid", `'${stub.name}': resource '${stub.resourcePath}' is not a valid entity resource${detail}.`);
+  }
+  if (entity.Name !== stub.name) {
+    return fail("NameCoupling", `Stub '${stub.name}' points at a resource defining entity '${entity.Name}' — the names must match.`);
+  }
+  return { ok: true, entityName: stub.name, resourceFile, entity };
+}
+function fail(code, message) {
+  return { ok: false, failure: { code, message } };
+}
+async function readStub(stubFile, fs) {
+  let parsed;
+  try {
+    const raw = await fs.readFile(stubFile);
+    if (raw === null) {
+      return failure("StubUnparsable", `'${stubFile}' could not be read.`);
+    }
+    parsed = JSON.parse(decode(raw));
+  } catch {
+    return failure("StubUnparsable", `'${stubFile}' is not valid JSON.`);
+  }
+  if (typeof parsed !== "object" || parsed === null || typeof parsed.name !== "string" || typeof parsed.resourcePath !== "string") {
+    return failure("StubUnparsable", `'${stubFile}' must be an object with string 'name' and 'resourcePath'.`);
+  }
+  return { stub: { name: parsed.name, resourcePath: parsed.resourcePath } };
+}
+async function readResource(resourceFile, entityName, resourcePath, fs) {
+  const missing = failure("ResourceMissing", `'${entityName}': definition resource '${resourcePath}' is missing. Restore it (check trash/backup) or delete the entity.`);
+  try {
+    const raw = await fs.readFile(resourceFile);
+    if (raw === null) {
+      return missing;
+    }
+    return { raw: JSON.parse(decode(raw)) };
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return failure("ResourceInvalid", `'${entityName}': resource '${resourcePath}' is not valid JSON.`);
+    }
+    return missing;
+  }
+}
+function decode(raw) {
+  return typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+}
+function failure(code, message) {
+  return { failure: { code, message } };
+}
+async function findSolutionRoot(startDir, fs) {
+  let dir = fs.path.resolve(startDir);
+  let unreadable;
+  for (;; ) {
+    const [error, entries] = await catchError(fs.readdir(dir));
+    if (error && isUnreadablePathError(error)) {
+      unreadable ??= error;
+    }
+    if (entries?.some((name) => name.endsWith(".uipx"))) {
+      if (unreadable) {
+        throw Object.assign(new Error(`Could not locate the solution from '${startDir}': ${unreadable.message}. A directory between here and the nearest .uipx cannot be read, and it may be the solution itself — fix read access and retry.`, { cause: unreadable }), { code: unreadable.code });
+      }
+      return dir;
+    }
+    const parent = fs.path.dirname(dir);
+    if (parent === dir) {
+      return;
+    }
+    dir = parent;
+  }
+}
+
+// ../packager/packager-tool-datafabric/src/pack/entity-project-tool.ts
+class EntityProjectTool extends ProjectTool {
+  async validateAsync(options, _cancellationToken) {
+    return this.checkProjectAsync(options.projectPath);
+  }
+  async packAsync(options, _cancellationToken) {
+    const result = await this.checkProjectAsync(options.projectPath);
+    if (result.isSuccess) {
+      this.logger.info("Entity project is valid — no package emitted; the entity resources are the deployable payload.");
+    }
+    return result;
+  }
+  async checkProjectAsync(projectPath) {
+    const fs = this.fileSystem;
+    const diagnostics = [];
+    let entries = [];
+    try {
+      entries = await fs.readdir(projectPath);
+    } catch {
+      return new ToolResult(ENTITY_VALIDATION_FAILED, `Entity project directory '${projectPath}' could not be read.`, [], "Check that the project path in the solution manifest points at an existing directory.");
+    }
+    const stubs = sorted(entries.filter((name) => name.endsWith(ENTITY_EXTENSION_CONST)));
+    for (const foreign of sorted(entries.filter((name) => name.endsWith(".flow")))) {
+      diagnostics.push({
+        file: fs.path.join(projectPath, foreign),
+        code: PACK_DIAGNOSTIC_CODES.misplacedMainFile,
+        message: `'${foreign}' is a Flow main file inside an Entity project — move it to a Flow project.`
+      });
+    }
+    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,
+          code: PACK_DIAGNOSTIC_CODES.noParentSolution,
+          message: "Entity project has no parent solution (.uipx not found) — the stubs' solution-relative resource pointers cannot resolve."
+        });
+      }
+    } else {
+      diagnostics.push(...await this.checkStubsAsync(projectPath, solutionDir, stubs));
+    }
+    if (diagnostics.length === 0) {
+      return ToolResult.success();
+    }
+    const result = new ToolResult(ENTITY_VALIDATION_FAILED, `Entity validation failed with ${diagnostics.length} issue(s). First: ${diagnostics[0]?.message}`, [], "Fix the listed entities (open them in the entity editor, or restore missing resources) and pack again.");
+    result.details = { diagnostics };
+    return result;
+  }
+  async checkStubsAsync(projectPath, solutionDir, stubs) {
+    const fs = this.fileSystem;
+    const diagnostics = [];
+    const allEntityNames = await collectSolutionEntityNames(solutionDir, fs);
+    for (const stubName of stubs) {
+      const stubFile = fs.path.join(projectPath, stubName);
+      const pair = await verifyPair(stubFile, solutionDir, fs);
+      if (!pair.ok) {
+        diagnostics.push({
+          file: stubFile,
+          code: pair.failure.code,
+          message: pair.failure.message
+        });
+        continue;
+      }
+      for (const diagnostic of validateEntity(pair.entity, {
+        siblingNames: withoutOneOccurrence(allEntityNames, pair.entityName)
+      })) {
+        diagnostics.push({
+          file: pair.resourceFile,
+          code: diagnostic.code,
+          message: diagnostic.message,
+          fieldName: diagnostic.fieldName
+        });
+      }
+    }
+    return diagnostics;
+  }
+}
+function sorted(names) {
+  return [...names].sort(compareCodeUnits);
+}
+function compareCodeUnits(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  return left > right ? 1 : 0;
+}
+// ../packager/packager-tool-datafabric/src/pack/entity-tool-factory.ts
+class EntityToolFactory {
+  supportedTypes = ["Entity"];
+  async createAsync(logger, fileSystem) {
+    return new EntityProjectTool(fileSystem, logger);
+  }
+}
+// ../packager/packager-tool-datafabric/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 {
+    files = await fs.readdir(dir);
+  } catch {
+    return found;
+  }
+  for (const file of files) {
+    if (!file.endsWith(".json")) {
+      continue;
+    }
+    try {
+      const raw = await fs.readFile(fs.path.join(dir, file), "utf-8");
+      if (raw === null) {
+        continue;
+      }
+      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 found;
+}
+export { ENTITY_VALIDATION_FAILED, AUTHORABLE_FIELD_TYPES, AuthoredFieldError, authorField, UNASSIGNED_FOLDER_ID, isLocallyAuthored, SYSTEM_FIELD_TEMPLATES, createEntitySkeleton, DIAGNOSTIC_CODES, validateEntity, ENTITY_RESOURCE_KIND, ENTITY_RESOURCE_TYPE, ENTITY_RESOURCE_API_VERSION, ENTITY_RESOURCE_DOC_VERSION, SOLUTION_FOLDER, ENTITY_RESOURCE_DIR, entityResourcePath, serialize, serializeEntityJson, EntityResourceError, wrapEntityJson, unwrapResource, updateResourceSchema, verifyPair, findSolutionRoot, EntityProjectTool, EntityToolFactory, readSolutionInlineEntities };
+
+//# debugId=6D66F13B2955B04964756E2164756E21