@uipath/packager-tool-datafabric 1.201.0-preview.134

package/dist/index.js

@@ -0,0 +1,815 @@
+// src/pack/entity-project-tool.ts
+import {
+  ProjectTool,
+  ToolResult
+} from "@uipath/solutionpackager-tool-core";
+
+// ../../common/dist/entity-name-rules.js
+var RESERVED_SQL_KEYWORDS_LOWER = new Set(["group", "order"]);
+var RESERVED_FIELD_NAMES_LOWER = new Set([
+  "id",
+  "createdby",
+  "createtime",
+  "updatedby",
+  "updatetime",
+  "recordowner",
+  "version"
+]);
+var RESERVED_KEYWORDS_LOWER = new Set([
+  "abstract",
+  "as",
+  "base",
+  "bool",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "checked",
+  "class",
+  "const",
+  "continue",
+  "decimal",
+  "default",
+  "delegate",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "event",
+  "explicit",
+  "extern",
+  "false",
+  "finally",
+  "fixed",
+  "float",
+  "for",
+  "foreach",
+  "goto",
+  "if",
+  "implicit",
+  "in",
+  "int",
+  "interface",
+  "internal",
+  "is",
+  "lock",
+  "long",
+  "namespace",
+  "new",
+  "null",
+  "object",
+  "operator",
+  "out",
+  "override",
+  "params",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "ref",
+  "return",
+  "sbyte",
+  "sealed",
+  "short",
+  "sizeof",
+  "stackalloc",
+  "static",
+  "string",
+  "struct",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "uint",
+  "ulong",
+  "unchecked",
+  "unsafe",
+  "ushort",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "while",
+  "addhandler",
+  "addressof",
+  "alias",
+  "and",
+  "andalso",
+  "boolean",
+  "byref",
+  "byval",
+  "call",
+  "cbool",
+  "cbyte",
+  "cchar",
+  "cdate",
+  "cdbl",
+  "cdec",
+  "cint",
+  "clng",
+  "cobj",
+  "csbyte",
+  "cshort",
+  "csng",
+  "cstr",
+  "ctype",
+  "cuint",
+  "culng",
+  "cushort",
+  "date",
+  "declare",
+  "dim",
+  "directcast",
+  "each",
+  "elseif",
+  "end",
+  "endif",
+  "erase",
+  "error",
+  "exit",
+  "friend",
+  "function",
+  "get",
+  "gettype",
+  "getxmlnamespace",
+  "global",
+  "gosub",
+  "goto",
+  "handles",
+  "implements",
+  "imports",
+  "inherits",
+  "integer",
+  "isnot",
+  "let",
+  "lib",
+  "like",
+  "loop",
+  "me",
+  "mod",
+  "module",
+  "mustinherit",
+  "mustoverride",
+  "mybase",
+  "myclass",
+  "narrowing",
+  "next",
+  "not",
+  "nothing",
+  "notinheritable",
+  "notoverridable",
+  "of",
+  "on",
+  "option",
+  "optional",
+  "or",
+  "orelse",
+  "overloads",
+  "overridable",
+  "overrides",
+  "paramarray",
+  "partial",
+  "property",
+  "raiseevent",
+  "redim",
+  "rem",
+  "removehandler",
+  "resume",
+  "select",
+  "set",
+  "shadows",
+  "shared",
+  "single",
+  "step",
+  "stop",
+  "structure",
+  "sub",
+  "synclock",
+  "then",
+  "to",
+  "trycast",
+  "uinteger",
+  "ushort",
+  "variant",
+  "wend",
+  "when",
+  "widening",
+  "with",
+  "withevents",
+  "writeonly",
+  "xor"
+]);
+function findReservedNameError(name, kind) {
+  if (kind === "field" && RESERVED_FIELD_NAMES_LOWER.has(name.toLowerCase())) {
+    return {
+      message: `Field name '${name}' is reserved`,
+      instructions: "The following field names are reserved by the platform (case-insensitive): Id, CreatedBy, CreateTime, UpdatedBy, UpdateTime, RecordOwner, Version. Pick a different name."
+    };
+  }
+  if (RESERVED_KEYWORDS_LOWER.has(name.toLowerCase())) {
+    return {
+      message: `${kind === "entity" ? "Entity" : kind === "field" ? "Field" : "Choice set"} name '${name}' is a reserved C# or VB keyword`,
+      instructions: "Reserved keywords are rejected with RESERVED_LANGUAGE_KEYWORDS. Pick a domain-specific rename, for example 'Case' -> 'WorkItem', 'Class' -> 'Category', 'New' -> 'IsNew'."
+    };
+  }
+  if (kind === "entity" && RESERVED_SQL_KEYWORDS_LOWER.has(name.toLowerCase())) {
+    return {
+      message: `Entity name '${name}' is a reserved SQL keyword`,
+      instructions: "The platform rejects 'Order' and 'Group' as entity names. Pick a domain-specific name such as 'PurchaseOrder' or 'TeamGroup'."
+    };
+  }
+  return null;
+}
+
+// ../../../node_modules/@uipath/entity-modeler/dist/chunk-FJZXCOIG.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 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/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/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"
+};
+function validateEntity(entity, ctx) {
+  const diagnostics = [];
+  if (!NAME_PATTERN.test(entity.Name)) {
+    diagnostics.push({
+      code: DIAGNOSTIC_CODES.entityNameInvalid,
+      message: `Entity name '${entity.Name}' must start with a letter and contain 3-100 letters or digits.`,
+      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"
+    });
+  }
+  const seenFieldNames = new Map;
+  for (const field of entity.Fields) {
+    if (!field.IsSystemField && !NAME_PATTERN.test(field.Name)) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.fieldNameInvalid,
+        message: `Field name '${field.Name}' must start with a letter and contain 3-100 letters or digits.`,
+        severity: "error",
+        fieldName: field.Name
+      });
+    }
+    if (!field.IsSystemField) {
+      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();
+    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 (!field.IsSystemField && !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
+      });
+    }
+  }
+  diagnostics.push(...validateSystemFields(entity));
+  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) {
+  const diagnostics = [];
+  for (const template of SYSTEM_FIELD_TEMPLATES) {
+    const actual = entity.Fields.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;
+}
+
+// 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"
+};
+
+// 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";
+function entityResourcePath(entityName) {
+  return `resources/${SOLUTION_FOLDER}/entity/native/${entityName}.json`;
+}
+
+// src/resource/resource-io.ts
+function serialize(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function serializeEntityJson(entity) {
+  return JSON.stringify(entity);
+}
+
+class EntityResourceError extends Error {
+  failure;
+  constructor(failure, message) {
+    super(message);
+    this.failure = failure;
+    this.name = "EntityResourceError";
+  }
+}
+function wrapEntityJson(entity) {
+  return {
+    docVersion: ENTITY_RESOURCE_DOC_VERSION,
+    resource: {
+      name: entity.Name,
+      kind: ENTITY_RESOURCE_KIND,
+      type: ENTITY_RESOURCE_TYPE,
+      apiVersion: ENTITY_RESOURCE_API_VERSION,
+      isOverridable: true,
+      dependencies: [],
+      runtimeDependencies: [],
+      folders: [{ fullyQualifiedName: SOLUTION_FOLDER }],
+      spec: {
+        resourceJson: serializeEntityJson(entity),
+        name: entity.Name,
+        displayName: entity.DisplayName,
+        description: entity.Description
+      },
+      locks: [],
+      key: entity.Id,
+      files: []
+    }
+  };
+}
+function unwrapResource(file) {
+  if (typeof file !== "object" || file === null || Array.isArray(file)) {
+    throw new EntityResourceError("NotAnObject", "Resource file is not a JSON object.");
+  }
+  const resource = file.resource;
+  if (typeof resource !== "object" || resource === null) {
+    throw new EntityResourceError("MissingResource", "Resource file has no 'resource' object.");
+  }
+  if (resource.kind !== ENTITY_RESOURCE_KIND) {
+    throw new EntityResourceError("NotAnEntityResource", `Resource kind is '${String(resource.kind)}', expected '${ENTITY_RESOURCE_KIND}'.`);
+  }
+  const spec = resource.spec;
+  if (typeof spec !== "object" || spec === null || typeof spec.resourceJson !== "string") {
+    throw new EntityResourceError("MissingSpec", "Resource file has no 'spec.resourceJson' string.");
+  }
+  try {
+    return JSON.parse(spec.resourceJson);
+  } catch {
+    throw new EntityResourceError("ResourceJsonUnparsable", "'spec.resourceJson' is not valid JSON.");
+  }
+}
+function updateResourceSchema(file, entity) {
+  return {
+    ...file,
+    resource: {
+      ...file.resource,
+      name: entity.Name,
+      spec: {
+        ...file.resource.spec,
+        resourceJson: serializeEntityJson(entity),
+        name: entity.Name,
+        displayName: entity.DisplayName,
+        description: entity.Description
+      }
+    }
+  };
+}
+
+// src/pack/verify-pair.ts
+async function verifyPair(stubFile, solutionDir, 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);
+  for (;; ) {
+    let entries = [];
+    try {
+      entries = await fs.readdir(dir);
+    } catch {
+      entries = [];
+    }
+    if (entries.some((name) => name.endsWith(".uipx"))) {
+      return dir;
+    }
+    const parent = fs.path.dirname(dir);
+    if (parent === dir) {
+      return;
+    }
+    dir = parent;
+  }
+}
+
+// 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 solutionDir = await findSolutionRoot(projectPath, fs);
+    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;
+}
+function withoutOneOccurrence(names, name) {
+  const siblings = [...names];
+  const self = siblings.indexOf(name);
+  if (self >= 0) {
+    siblings.splice(self, 1);
+  }
+  return siblings;
+}
+async function collectSolutionEntityNames(solutionDir, fs) {
+  const names = [];
+  let topLevel = [];
+  try {
+    topLevel = await fs.readdir(solutionDir);
+  } catch {
+    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 {}
+  }
+  return names;
+}
+// src/pack/entity-tool-factory.ts
+class EntityToolFactory {
+  supportedTypes = ["Entity"];
+  async createAsync(logger, fileSystem) {
+    return new EntityProjectTool(fileSystem, logger);
+  }
+}
+export {
+  DIAGNOSTIC_CODES,
+  ENTITY_RESOURCE_API_VERSION,
+  ENTITY_RESOURCE_DOC_VERSION,
+  ENTITY_RESOURCE_KIND,
+  ENTITY_RESOURCE_TYPE,
+  ENTITY_VALIDATION_FAILED,
+  EntityProjectTool,
+  EntityResourceError,
+  EntityToolFactory,
+  SOLUTION_FOLDER,
+  SYSTEM_FIELD_TEMPLATES,
+  createEntitySkeleton,
+  entityResourcePath,
+  findSolutionRoot,
+  serialize,
+  serializeEntityJson,
+  unwrapResource,
+  updateResourceSchema,
+  validateEntity,
+  verifyPair,
+  wrapEntityJson
+};
+
+//# debugId=EEB462776EC352DB64756E2164756E21