@uipath/case-tool 1.203.0-preview.205 → 1.204.0-preview.206

package/dist/{packager-tool-r84ng21s.js → packager-tool-sag9gz55.js}

@@ -6,6 +6,7 @@ var RESOURCE_TYPES = [
   "processOrchestration",
   "caseManagement",
   "flow",
+  "function",
   "typecache-activities",
   "typecache-triggers",
   "typecache-packages",
@@ -44,6 +45,7 @@ var GET_SEARCHABLE_TYPES = [
   { type: "processOrchestration", idField: "entityKey" },
   { type: "caseManagement", idField: "entityKey" },
   { type: "flow", idField: "entityKey" },
+  { type: "function", idField: "entityKey" },
   { type: "action-apps", idField: "id" },
   ...TYPECACHE_INDEX_TYPES.map((type) => ({
     type,
@@ -54,4 +56,4 @@ var GET_SEARCHABLE_TYPES = [
 
 export { RESOURCE_TYPES, TYPECACHE_ACTIVITY_INDEX_TYPES, TYPECACHE_TRIGGER_INDEX_TYPES, TYPECACHE_PACKAGE_INDEX_TYPES, TYPECACHE_INDEX_TYPES, GET_SEARCHABLE_TYPES };
 
-//# debugId=A7AD4F9C62720BB264756E2164756E21
+//# debugId=114584F4923AC76664756E2164756E21

package/dist/{packager-tool-0mj06yen.js → packager-tool-sq931c23.js}

@@ -1,23 +1,6 @@
-// src/utils/shortId.ts
-var ALPHANUMERIC = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-var getRandomBytes = (n) => globalThis.crypto.getRandomValues(new Uint8Array(n));
-function prefixedId(prefix, count = 6) {
-  let result = prefix;
-  const limit = 256 - 256 % ALPHANUMERIC.length;
-  const bytes = getRandomBytes(count * 2);
-  let i = 0;
-  let byteIdx = 0;
-  while (i < count) {
-    if (byteIdx >= bytes.length)
-      break;
-    const b = bytes[byteIdx++];
-    if (b < limit) {
-      result += ALPHANUMERIC[b % ALPHANUMERIC.length];
-      i++;
-    }
-  }
-  return result;
-}
+import {
+  prefixedId
+} from "./packager-tool-mknccck5.js";
 
 // src/utils/binding-builder.ts
 function createBinding(propertyAttribute, defaultValue, resource, resourceKey) {
@@ -60,6 +43,6 @@ function createConnectorBindings(connectorKey, connectionId, folderKey) {
   return [connectionBinding, folderKeyBinding];
 }
 
-export { prefixedId, createTaskBindings, createConnectorBindings };
+export { createTaskBindings, createConnectorBindings };
 
-//# debugId=23ED2DE520E5BD2164756E2164756E21
+//# debugId=536BD326FFC9BE9264756E2164756E21

package/dist/{packager-tool-yrsrzz1a.js → packager-tool-v99ygh9f.js}

@@ -13,7 +13,7 @@ import {
 } from "./packager-tool-yc4kw997.js";
 import {
   getFileSystem
-} from "./packager-tool-0v3s8r01.js";
+} from "./packager-tool-xdxr3ync.js";
 import {
   __require
 } from "./packager-tool-1yh8g550.js";
@@ -732,6 +732,11 @@ var pickName = (claims) => {
   const username = asString(claims?.preferred_username);
   return asString(claims?.name) ?? (looksLikeEmail(username) ? undefined : username);
 };
+var pickScopes = (claims) => {
+  const raw = claims?.scope;
+  const scopes = Array.isArray(raw) ? raw.filter((entry) => asString(entry) !== undefined) : typeof raw === "string" ? raw.split(/\s+/).filter(Boolean) : [];
+  return scopes.length > 0 ? scopes : undefined;
+};
 var resolveSessionIdentity = (accessToken, authFlow) => {
   const claims = accessToken ? decodeClaims(accessToken) : undefined;
   const email = pickEmail(claims);
@@ -757,6 +762,7 @@ var resolveSessionIdentity = (accessToken, authFlow) => {
     identity.clientId = clientId;
   return identity;
 };
+var readTokenScopes = (accessToken) => accessToken ? pickScopes(decodeClaims(accessToken)) : undefined;
 
 // ../auth/src/envAuth.ts
 var ENV_AUTH_ENABLE_VAR = "UIPATH_CLI_ENABLE_ENV_AUTH";
@@ -829,6 +835,7 @@ var readAuthFromEnv = () => {
   const expiration = getTokenExpiration(accessToken);
   const loginStatus = expiration && expiration <= new Date ? "Expired" : "Logged in";
   const identity = resolveSessionIdentity(accessToken);
+  const scopes = readTokenScopes(accessToken);
   return {
     loginStatus,
     accessToken,
@@ -839,7 +846,8 @@ var readAuthFromEnv = () => {
     tenantId,
     expiration,
     source: "env-vars" /* EnvironmentVariables */,
-    ...identity ? { identity } : {}
+    ...identity ? { identity } : {},
+    ...scopes ? { scopes } : {}
   };
 };
 
@@ -1487,10 +1495,15 @@ async function buildFileStatus(tokens, credentials, globalHint) {
 }
 function identityFields(accessToken, credentials) {
   const identity = resolveSessionIdentity(accessToken, parseAuthFlow(credentials[AUTH_FLOW_ENV_VAR]));
-  return identity ? { identity } : {};
+  const scopes = readTokenScopes(accessToken);
+  return {
+    ...identity ? { identity } : {},
+    ...scopes ? { scopes } : {}
+  };
 }
 function buildRobotStatus(robotCreds) {
   const identity = resolveSessionIdentity(robotCreds.accessToken);
+  const scopes = readTokenScopes(robotCreds.accessToken);
   return {
     loginStatus: "Logged in",
     accessToken: robotCreds.accessToken,
@@ -1502,7 +1515,8 @@ function buildRobotStatus(robotCreds) {
     issuer: robotCreds.issuer,
     expiration: getTokenExpiration(robotCreds.accessToken),
     source: "robot" /* Robot */,
-    ...identity ? { identity } : {}
+    ...identity ? { identity } : {},
+    ...scopes ? { scopes } : {}
   };
 }
 var isFileNotFoundError = (error) => {
@@ -1769,7 +1783,8 @@ var getAuthContext = async (options = {}) => {
     organizationId: status.organizationId,
     organizationName: status.organizationName,
     tenantId: status.tenantId,
-    tenantName
+    tenantName,
+    identity: status.identity
   };
 };
 var getAuthEnv = async (options = {}) => {
@@ -2417,7 +2432,7 @@ var authenticate = async ({
     const { BrowserAuthStrategy } = await import("./browser-strategy-6atc7v8s.js");
     strategy = new BrowserAuthStrategy;
   } else {
-    const { NodeAuthStrategy } = await import("./node-strategy-gc4sg6a2.js");
+    const { NodeAuthStrategy } = await import("./node-strategy-5pz40tee.js");
     strategy = new NodeAuthStrategy;
   }
   const code = await strategy.execute(authUrl, effectiveRedirectUriUrl, state, {
@@ -2437,6 +2452,6 @@ var authenticate = async ({
   });
 };
 
-export { setAuthFileConfig, InvalidBaseUrlError, DEFAULT_AUTH_PROFILE, AuthProfileValidationError, normalizeAuthProfileName, setActiveAuthProfile, clearActiveAuthProfile, getActiveAuthProfile, runWithAuthProfile, resolveAuthProfileFilePath, getActiveAuthProfileFilePath, getAuthProfilesRootPath, resolveAuthProfileDirPath, listAuthProfileNamesAsync, authProfileExistsAsync, deleteAuthProfileAsync, parseJWT, parseAuthFlow, resolveSessionIdentity, ENV_AUTH_ENABLE_VAR, ENFORCE_ROBOT_AUTH_VAR, ENV_AUTH_VARS, EnvAuthConfigError, isEnvAuthEnabled, isRobotAuthEnforced, readAuthFromEnv, refreshTokenFingerprint, loadRefreshBreaker, saveRefreshBreaker, clearRefreshBreaker, registerRobotClientLoader, TokenRefreshOAuthError, isTokenRefreshOAuthFailure, refreshAccessToken, AUTH_FLOW_ENV_VAR, DEFAULT_AUTH_FILENAME, DEFAULT_ENV_FILENAME, resolveEnvFileLocationAsync, resolveEnvFilePathAsync, loadEnvFileAsync, saveEnvFileAsync, CredentialSource, getLoginStatusAsync, getLoginStatusWithDeps, getAuthContext, getAuthEnv, describeAuthProfilesAsync, ClientCredentialsAuthenticationError, clientCredentialsLogin, JWT_BEARER_ASSERTION_TYPE, FederatedCredentialsAuthenticationError, federatedCredentialsLogin, fetchTenantsAndOrganizations, TENANT_SELECTION_REQUIRED_CODE, INVALID_TENANT_CODE, TenantSelectionError, TenantSelectionRequiredError, InvalidTenantError, isTenantSelectionError, selectTenantWithDeps, interactiveLoginWithDeps, interactiveLogin, logoutWithDeps, logout, authenticate };
+export { setAuthFileConfig, InvalidBaseUrlError, DEFAULT_AUTH_PROFILE, AuthProfileValidationError, normalizeAuthProfileName, setActiveAuthProfile, clearActiveAuthProfile, getActiveAuthProfile, runWithAuthProfile, resolveAuthProfileFilePath, getActiveAuthProfileFilePath, getAuthProfilesRootPath, resolveAuthProfileDirPath, listAuthProfileNamesAsync, authProfileExistsAsync, deleteAuthProfileAsync, parseJWT, parseAuthFlow, resolveSessionIdentity, readTokenScopes, ENV_AUTH_ENABLE_VAR, ENFORCE_ROBOT_AUTH_VAR, ENV_AUTH_VARS, EnvAuthConfigError, isEnvAuthEnabled, isRobotAuthEnforced, readAuthFromEnv, refreshTokenFingerprint, loadRefreshBreaker, saveRefreshBreaker, clearRefreshBreaker, registerRobotClientLoader, TokenRefreshOAuthError, isTokenRefreshOAuthFailure, refreshAccessToken, AUTH_FLOW_ENV_VAR, DEFAULT_AUTH_FILENAME, DEFAULT_ENV_FILENAME, resolveEnvFileLocationAsync, resolveEnvFilePathAsync, loadEnvFileAsync, saveEnvFileAsync, CredentialSource, getLoginStatusAsync, getLoginStatusWithDeps, getAuthContext, getAuthEnv, describeAuthProfilesAsync, ClientCredentialsAuthenticationError, clientCredentialsLogin, JWT_BEARER_ASSERTION_TYPE, FederatedCredentialsAuthenticationError, federatedCredentialsLogin, fetchTenantsAndOrganizations, TENANT_SELECTION_REQUIRED_CODE, INVALID_TENANT_CODE, TenantSelectionError, TenantSelectionRequiredError, InvalidTenantError, isTenantSelectionError, selectTenantWithDeps, interactiveLoginWithDeps, interactiveLogin, logoutWithDeps, logout, authenticate };
 
-//# debugId=9A92DFA480A9998F64756E2164756E21
+//# debugId=13BF51602EF4AFD864756E2164756E21

package/dist/packager-tool-wj9d9mqe.js

@@ -0,0 +1,267 @@
+import {
+  NugetConstants,
+  NugetPackager,
+  Path,
+  ProjectTool,
+  TemporaryStorageService,
+  ToolResult,
+  ensureContentOperateFile,
+  toolsFactoryRepository
+} from "./packager-tool-4rqd21wc.js";
+
+// ../packager/packager-tool-case/src/case-plan-file.ts
+var CasePlanFileNames = [
+  "caseplan.case",
+  "caseplan.json",
+  "case.stage.json",
+  "default.stage.json"
+];
+var casePlanSidecarName = (casePlanFileName) => `${casePlanFileName}.bpmn`;
+var findCasePlanFileName = (entries) => {
+  const present = new Set(entries);
+  return CasePlanFileNames.find((candidate) => present.has(candidate));
+};
+var stripDeclaredFilePathPrefix = (filePath) => {
+  const withoutLeadingSlash = filePath.startsWith("/") ? filePath.slice(1) : filePath;
+  return withoutLeadingSlash.startsWith("content/") ? withoutLeadingSlash.slice("content/".length) : withoutLeadingSlash;
+};
+var resolveDeclaredFileName = (filePath) => {
+  const stripped = stripDeclaredFilePathPrefix(filePath.split("#")[0]);
+  return stripped.includes("/") ? "" : stripped;
+};
+var normalizeEntryPointPath = (filePath) => `/${stripDeclaredFilePathPrefix(filePath)}`;
+var entryPointBpmnNames = (entryPointsJson) => {
+  try {
+    const parsed = JSON.parse(entryPointsJson);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("document is not an object");
+    }
+    if (parsed.entryPoints !== undefined && !Array.isArray(parsed.entryPoints)) {
+      throw new Error("entryPoints is not a list");
+    }
+    const resolvedNames = (parsed.entryPoints ?? []).map((entry) => typeof entry.filePath === "string" ? resolveDeclaredFileName(entry.filePath) : "");
+    if (resolvedNames.includes("")) {
+      throw new Error("an entry point has no usable filePath");
+    }
+    const names = resolvedNames.filter((name) => name.endsWith(".bpmn"));
+    return [...new Set(names)];
+  } catch {
+    return null;
+  }
+};
+var misnamedEntryPointBpmn = (declared, casePlanFileName) => {
+  const own = casePlanSidecarName(casePlanFileName);
+  const otherPlans = new Set(CasePlanFileNames.filter((name) => name !== casePlanFileName).map(casePlanSidecarName));
+  return declared.find((file) => file !== own && otherPlans.has(file));
+};
+var buildCasePackageDescriptor = (contentFileNames) => ({
+  $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
+  files: {
+    [NugetConstants.OperateFileName]: `${NugetConstants.ContentFolderName}/${NugetConstants.OperateFileName}`,
+    [NugetConstants.EntryPointsFileName]: `${NugetConstants.ContentFolderName}/${NugetConstants.EntryPointsFileName}`,
+    [NugetConstants.BindingsFileId]: `${NugetConstants.ContentFolderName}/${NugetConstants.BindingsV2FileName}`,
+    ...Object.fromEntries(contentFileNames.filter((name) => name.endsWith(".bpmn") || CasePlanFileNames.includes(name)).map((name) => [
+      name,
+      `${NugetConstants.ContentFolderName}/${name}`
+    ]))
+  }
+});
+
+// ../packager/packager-tool-case/src/case-bpmn-compiler.ts
+var COMPILER_KEY = Symbol.for("@uipath/packager-tool-case/caseBpmnCompiler");
+var _global = globalThis;
+function registerCaseBpmnCompiler(caseBpmnCompiler) {
+  _global[COMPILER_KEY] = caseBpmnCompiler;
+}
+function getCaseBpmnCompiler() {
+  return _global[COMPILER_KEY];
+}
+
+// ../packager/packager-tool-case/src/case-tool.ts
+var CaseConstants = {
+  EntryPointsFileName: "entry-points.json"
+};
+
+class CaseTool extends ProjectTool {
+  _temporaryStorage;
+  constructor(fileSystem, logger) {
+    super(fileSystem, logger);
+    this._temporaryStorage = new TemporaryStorageService(fileSystem);
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info("Restore operation is not required for Case Management projects");
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info("Validate operation is not required for Case Management projects");
+    return ToolResult.success();
+  }
+  async buildAsync(options, _cancellationToken) {
+    const tempFolder = await this._temporaryStorage.getTempFolderPath();
+    const localBuildFolder = Path.join(tempFolder, NugetConstants.OutputFolderName);
+    const contentFolder = Path.join(localBuildFolder, NugetConstants.ContentFolderName);
+    try {
+      this.logger.progress("Copying files...");
+      await this.copyFiles(options.projectPath, contentFolder);
+      this.logger.progress("Compiling case plan to BPMN...");
+      const compileResult = await this.compileCasePlan(options.projectPath, contentFolder);
+      if (!compileResult.isSuccess) {
+        return compileResult;
+      }
+      this.logger.progress("Creating operate.json file...");
+      await this.createOperateFile(options, contentFolder);
+      this.logger.progress("Creating package-descriptor.json file...");
+      await this.createPackageDescriptor(localBuildFolder, contentFolder);
+      return new ToolResult("SUCCESS" /* Success */, "done", [
+        localBuildFolder
+      ]);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.toString() : String(error);
+      this.logger.error(errorMessage);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, "An error occurred while building Case Management project files");
+    }
+  }
+  async packAsync(options, cancellationToken) {
+    const buildResult = await this.buildAsync(options, cancellationToken);
+    if (!buildResult.isSuccess) {
+      return buildResult;
+    }
+    const localBuildFolder = buildResult.packages[0];
+    try {
+      this.logger.progress("Creating NuGet package...");
+      const nupkgFileName = `${options.package.id}.${options.package.version}.nupkg`;
+      const nupkgPath = Path.join(options.outputPath, nupkgFileName);
+      const packager = new NugetPackager(this.fileSystem);
+      const result = await packager.packAsync(localBuildFolder, options.package, nupkgPath);
+      this.logger.progress("Package created successfully");
+      return new ToolResult("SUCCESS" /* Success */, "done", [
+        result.outputPath
+      ]);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.toString() : String(error);
+      this.logger.error(errorMessage);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, "An error occurred while packing Case Management project");
+    }
+  }
+  async dispose() {
+    this.logger.info("Disposing Case Management Tool");
+    try {
+      await this._temporaryStorage.cleanup();
+    } catch {}
+  }
+  async copyFiles(sourcePath, contentFolder) {
+    await this.fileSystem.mkdir(contentFolder);
+    const files = await this.fileSystem.readdir(sourcePath);
+    for (const file of files) {
+      const sourceFile = Path.join(sourcePath, file);
+      const stat = await this.fileSystem.stat(sourceFile);
+      if (stat?.isFile()) {
+        const content = await this.fileSystem.readFile(sourceFile);
+        if (content) {
+          const destinationFile = Path.join(contentFolder, file);
+          await this.fileSystem.writeFile(destinationFile, content);
+        }
+      }
+    }
+  }
+  async compileCasePlan(projectPath, contentFolder) {
+    const compile = getCaseBpmnCompiler();
+    const casePlanFileName = findCasePlanFileName(await this.fileSystem.readdir(projectPath));
+    if (!compile || !casePlanFileName) {
+      return this.checkEntryPointBpmnPresent(contentFolder, casePlanFileName);
+    }
+    const sidecarFileName = casePlanSidecarName(casePlanFileName);
+    const casePlanPath = Path.join(projectPath, casePlanFileName);
+    const casePlan = await this.fileSystem.readFile(casePlanPath);
+    if (!casePlan || casePlan.length === 0) {
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `'${casePlanFileName}' in ${projectPath} is empty, so there is nothing to compile into '${sidecarFileName}'. Author the case plan, or re-scaffold the project with 'uip maestro case init'.`);
+    }
+    try {
+      const bpmnXml = await compile(new TextDecoder().decode(casePlan));
+      await this.fileSystem.writeFile(Path.join(contentFolder, sidecarFileName), bpmnXml);
+      return await this.checkEntryPointBpmnPresent(contentFolder, casePlanFileName);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(message);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Failed to compile '${casePlanFileName}' into '${sidecarFileName}': ${message}. Run 'uip maestro case validate ${projectPath}' to find the problem in the case plan, then pack again.`);
+    }
+  }
+  async checkEntryPointBpmnPresent(contentFolder, casePlanFileName) {
+    const referenced = await this.readEntryPointBpmnFiles(contentFolder);
+    if (referenced === null) {
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `'${CaseConstants.EntryPointsFileName}' could not be read as JSON, so pack cannot check that the BPMN it declares is in the package. Fix or re-scaffold '${CaseConstants.EntryPointsFileName}', then pack again.`);
+    }
+    const own = casePlanFileName ? casePlanSidecarName(casePlanFileName) : undefined;
+    const fix = own ?? `Author a case plan (${CasePlanFileNames.join(", ")}) so pack can compile it (see 'uip maestro case init'), then pack again.`;
+    const firstEntry = await this.firstEntryPointFileName(contentFolder);
+    if (firstEntry && !referenced.includes(firstEntry)) {
+      const firstEntryFix = own ? `Point the first entry point at '${own}', then pack again.` : fix;
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `'${CaseConstants.EntryPointsFileName}' first entry point resolves to '${firstEntry}', which is not a declared .bpmn file this project ships, so operate.json's main would name a file pack cannot produce. ${firstEntryFix}`);
+    }
+    if (referenced.length === 0) {
+      return ToolResult.success();
+    }
+    const contentFiles = await this.fileSystem.readdir(contentFolder);
+    const missing = referenced.filter((file) => !contentFiles.includes(file));
+    if (missing.length === 0) {
+      if (casePlanFileName) {
+        const misnamed = misnamedEntryPointBpmn(referenced, casePlanFileName);
+        if (misnamed) {
+          return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `'${CaseConstants.EntryPointsFileName}' points at 'content/${misnamed}', the sidecar of a case plan this project does not carry. '${casePlanFileName}' compiles to '${own}', so the entry point would resolve to a BPMN pack did not produce. Point it at '${own}', then pack again.`);
+        }
+      }
+      return ToolResult.success();
+    }
+    const missingFix = casePlanFileName ? `Add the missing file to the project, or point '${CaseConstants.EntryPointsFileName}' at the BPMN the project does ship, then pack again.` : fix;
+    const missingList = missing.map((f) => `'content/${f}'`).join(", ");
+    return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `'${CaseConstants.EntryPointsFileName}' points at ${missingList}, which the package does not contain, so it would deploy and activate and then fault every job. ${missingFix}`);
+  }
+  async readEntryPointBpmnFiles(contentFolder) {
+    const entryPointsPath = Path.join(contentFolder, CaseConstants.EntryPointsFileName);
+    if (!await this.fileSystem.exists(entryPointsPath)) {
+      return [];
+    }
+    const raw = await this.fileSystem.readFile(entryPointsPath);
+    if (!raw || raw.length === 0) {
+      return null;
+    }
+    return entryPointBpmnNames(new TextDecoder().decode(raw));
+  }
+  async firstEntryPointFileName(contentFolder) {
+    const raw = await this.fileSystem.readFile(Path.join(contentFolder, CaseConstants.EntryPointsFileName));
+    const parsed = JSON.parse(raw ? new TextDecoder().decode(raw) : "{}");
+    const filePath = parsed.entryPoints?.[0]?.filePath ?? "";
+    return resolveDeclaredFileName(filePath);
+  }
+  async createOperateFile(options, contentFolder) {
+    await ensureContentOperateFile(this.fileSystem, {
+      contentFolder,
+      projectPath: options.projectPath,
+      projectStorageId: options.projectStorageId,
+      contentType: "CaseManagement" /* CaseManagement */
+    });
+  }
+  async createPackageDescriptor(localBuildFolder, contentFolder) {
+    const contentFiles = await this.fileSystem.readdir(contentFolder);
+    const packageDescriptorPath = Path.join(localBuildFolder, NugetConstants.ContentFolderName, NugetConstants.PackageDescriptorFileName);
+    const packageDescriptorJson = JSON.stringify(buildCasePackageDescriptor(contentFiles), null, 2);
+    await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
+  }
+}
+
+// ../packager/packager-tool-case/src/case-tool-factory.ts
+class CaseToolFactory {
+  supportedTypes = [
+    "CaseManagement" /* CaseManagement */
+  ];
+  async createAsync(logger, fileSystem) {
+    return new CaseTool(fileSystem, logger);
+  }
+}
+
+// ../packager/packager-tool-case/src/index.ts
+toolsFactoryRepository.registerProjectToolFactory(new CaseToolFactory);
+
+export { registerCaseBpmnCompiler, CasePlanFileNames, casePlanSidecarName, findCasePlanFileName, resolveDeclaredFileName, normalizeEntryPointPath, entryPointBpmnNames, misnamedEntryPointBpmn, buildCasePackageDescriptor, CaseToolFactory };
+
+//# debugId=3611FD39A370A3B664756E2164756E21

package/dist/{packager-tool-hz1mz8fs.js → packager-tool-wjaya2k2.js}

@@ -1,9 +1,9 @@
 import {
   readStdin
-} from "./packager-tool-kpcjnxd1.js";
+} from "./packager-tool-58kx79ta.js";
 import {
   getFileSystem
-} from "./packager-tool-0v3s8r01.js";
+} from "./packager-tool-xdxr3ync.js";
 
 // ../maestro-sdk/src/json-input.ts
 async function readJsonFile(filePath) {

package/dist/packager-tool-xcd87qyx.js

@@ -0,0 +1,44 @@
+import {
+  prefixedId
+} from "./packager-tool-mknccck5.js";
+import {
+  DEFAULT_TRIGGER_ID,
+  DEFAULT_TRIGGER_LABEL
+} from "./packager-tool-nj4seavy.js";
+
+// src/utils/case-document.ts
+var CASE_PLAN_FILENAME = "caseplan.json";
+function buildMinimalCaseDocument(options) {
+  return {
+    id: prefixedId("case-", 10),
+    name: options.name,
+    version: options.schemaVersion,
+    ...options.description !== undefined && {
+      description: options.description
+    },
+    bindings: [],
+    variables: { inputOutputs: [] },
+    metadata: {
+      caseIdentifier: options.caseIdentifier ?? options.name,
+      caseAppEnabled: options.caseAppEnabled ?? false,
+      caseIdentifierType: options.identifierType ?? "constant",
+      publishVersion: 2
+    },
+    nodes: [
+      {
+        id: DEFAULT_TRIGGER_ID,
+        type: "uipath.case.trigger",
+        data: {
+          typeVersion: "1.0.0",
+          display: { label: DEFAULT_TRIGGER_LABEL },
+          inputs: { serviceType: "None" }
+        }
+      }
+    ],
+    edges: []
+  };
+}
+
+export { CASE_PLAN_FILENAME, buildMinimalCaseDocument };
+
+//# debugId=5271E14EC19FCE1A64756E2164756E21

package/dist/{packager-tool-0v3s8r01.js → packager-tool-xdxr3ync.js}

@@ -230,8 +230,10 @@ class NodeFileSystem {
 
 // ../filesystem/src/index.ts
 var fsInstance = new NodeFileSystem;
+var setFileSystem = (_fs) => () => {};
 var getFileSystem = () => fsInstance;
+var getFileSystemAsync = async () => fsInstance;
 
-export { getFileSystem };
+export { NodeFileSystem, setFileSystem, getFileSystem, getFileSystemAsync };
 
-//# debugId=25EC9C9B4767723E64756E2164756E21
+//# debugId=3E49815A855BD0ED64756E2164756E21

package/dist/{packager-tool-61hxhgeg.js → packager-tool-xkgq5fkf.js}

@@ -1,6 +1,6 @@
 import {
   catchError
-} from "./packager-tool-kpcjnxd1.js";
+} from "./packager-tool-58kx79ta.js";
 
 // src/services/schema-utils.ts
 function getMutatedType(variable) {
@@ -351,6 +351,6 @@ function addVarIdsToInputsOutputs(params) {
   return { inputsWithVars, outputsWithVars };
 }
 
-export { transformSchemaToVariables, convertActionArgsToVariables, mapEntryPointVariablesToInputOutput, buildErrorOutput, addVarIdsToInputsOutputs };
+export { transformSchemaToVariables, convertActionArgsToVariables, FILE_TYPE_JSON_SCHEMA, mapEntryPointVariablesToInputOutput, buildErrorOutput, addVarIdsToInputsOutputs };
 
-//# debugId=F4923EB769649F2664756E2164756E21
+//# debugId=DBAEB71CB3648B7264756E2164756E21

package/dist/packager-tool.js

@@ -1,10 +1,10 @@
-import {
-  toolsFactoryRepository
-} from "./packager-tool-sfkyb4kz.js";
 import {
   CaseToolFactory,
   registerCaseBpmnCompiler
-} from "./packager-tool-83qnybab.js";
+} from "./packager-tool-wj9d9mqe.js";
+import {
+  toolsFactoryRepository
+} from "./packager-tool-4rqd21wc.js";
 import"./packager-tool-b098y4a2.js";
 import {
   __require,
@@ -13,7 +13,7 @@ import {
 
 // ../packager/packager-tool-case/src/node.ts
 var compileCasePlan = async (casePlanJson) => {
-  const { serializeCaseDiskJsonToBpmnAndRulesJson } = await import("./index-k4xz16db.js").then((m)=>__toESM(m.default,1));
+  const { serializeCaseDiskJsonToBpmnAndRulesJson } = await import("./index-wmffgzmr.js").then((m)=>__toESM(m.default,1));
   const { bpmnXml } = await serializeCaseDiskJsonToBpmnAndRulesJson(casePlanJson);
   return bpmnXml;
 };
@@ -30,4 +30,4 @@ export {
   registerPackagerFactories
 };
 
-//# debugId=59E72E6560C763B364756E2164756E21
+//# debugId=39B4FB59B227752B64756E2164756E21

package/dist/{project-artifacts-8snev67g.js → project-artifacts-wzrhketn.js}

@@ -4,7 +4,7 @@ import {
 
 // src/services/project-artifacts.ts
 async function ensureProjectArtifacts(args) {
-  const { addProjectArtifactsToSolutionAsync } = await import("./index-jxj2jz45.js");
+  const { addProjectArtifactsToSolutionAsync } = await import("./index-rgw7caht.js");
   return addProjectArtifactsToSolutionAsync(args);
 }
 export {

package/dist/resolved-check-p99hysaw.js

@@ -0,0 +1,50 @@
+import {
+  namedValue
+} from "./packager-tool-f78ntj5g.js";
+import"./packager-tool-1yh8g550.js";
+
+// src/services/sdd-convert/resolved-check.ts
+var isDeferredEntry = (entry) => {
+  if (typeof entry.selected?.name === "string" && entry.selected.name !== "") {
+    return false;
+  }
+  if (entry.gateDecision === "resolve-at-build")
+    return true;
+  return [entry.taskTypeId, entry.typeId, entry.connectionId].some((slot) => typeof slot === "string" && slot.trimStart().toLowerCase().startsWith("<unresolved"));
+};
+var staleResolvedEntry = (model, entries) => {
+  for (const entry of entries) {
+    const picked = entry.selected;
+    const selected = typeof picked?.name === "string" && picked.name !== "";
+    if (!selected && !isDeferredEntry(entry))
+      continue;
+    const where = `stage "${entry.stage ?? ""}" task "${entry.task ?? ""}"`;
+    const task = model.stages.find((stage) => stage.name === entry.stage)?.tasks.find((candidate) => candidate.name === entry.task);
+    if (task === undefined)
+      return `${where} is not a task in this SDD`;
+    const query = entry.searchQuery;
+    if (query === undefined) {
+      return `${where} carries no \`searchQuery\`, so it cannot be matched to this SDD's task`;
+    }
+    const name = namedValue(task.resourceName);
+    const folder = namedValue(task.folder);
+    const queried = { name: query.name ?? "", folder: query.folder ?? "" };
+    const differs = [];
+    if (queried.name !== name) {
+      differs.push(`its \`searchQuery.name\` is "${queried.name}" and this SDD names the resource "${name}"`);
+    }
+    if (queried.folder !== folder) {
+      differs.push(queried.folder === "" ? `its \`searchQuery\` has no folder and this SDD names the folder "${folder}"` : folder === "" ? `its \`searchQuery.folder\` is "${queried.folder}" and this SDD names no folder` : `its \`searchQuery.folder\` is "${queried.folder}" and this SDD names the folder "${folder}"`);
+    }
+    if (differs.length > 0) {
+      return `${where} does not match: ${differs.join("; and ")}`;
+    }
+  }
+  return;
+};
+export {
+  isDeferredEntry,
+  staleResolvedEntry
+};
+
+//# debugId=594536652D5E05EC64756E2164756E21