@uipath/flow-tool 1.201.0-preview.133 → 1.202.0-preview.134

package/dist/packager-tool-27avrkyk.js

@@ -0,0 +1,15 @@
+// src/services/binding-resource-types.ts
+var VALID_RESOURCE_TYPES = [
+  "connection",
+  "queue",
+  "process",
+  "folderKey",
+  "index",
+  "memorySpace",
+  "bucket",
+  "app"
+];
+
+export { VALID_RESOURCE_TYPES };
+
+//# debugId=1EBE786778F72E9364756E2164756E21

package/dist/packager-tool-2vnjw67f.js

@@ -0,0 +1,79 @@
+import {
+  getMigrationChain,
+  migrateWorkflowToFloor,
+  minimumSupportedVersion,
+  registerFlowMigrationsI18n,
+  runtimeMigrations,
+  runtimeVersion
+} from "./packager-tool-1r8c83fc.js";
+import {
+  instance
+} from "./packager-tool-m5qfverj.js";
+
+// src/services/flow-migration-check.ts
+if (!instance.isInitialized) {
+  instance.init({
+    lng: "en",
+    fallbackLng: "en",
+    defaultNS: "validation",
+    resources: {},
+    interpolation: { escapeValue: false }
+  });
+}
+registerFlowMigrationsI18n(instance);
+function captureMigrationIssues() {
+  const paths = [];
+  const tracker = {
+    trackError: (_error, _severity, details) => {
+      if (!("issues" in details))
+        return;
+      const issues = details.issues;
+      if (!Array.isArray(issues))
+        return;
+      for (const issue of issues) {
+        if (!issue || typeof issue !== "object")
+          continue;
+        if (!("path" in issue))
+          continue;
+        const path = issue.path;
+        if (Array.isArray(path) && path.length > 0) {
+          paths.push(path.map(String).join("."));
+        }
+      }
+    }
+  };
+  return { tracker, fieldPaths: () => [...new Set(paths)] };
+}
+function formatMigrationFailureMessage(step, rawMessage, fieldPaths) {
+  const parts = [`Workflow migration failed at ${step}: ${rawMessage}.`];
+  if (fieldPaths.length > 0) {
+    const shown = fieldPaths.slice(0, 10);
+    const extra = fieldPaths.length > shown.length ? `, +${fieldPaths.length - shown.length} more` : "";
+    parts.push(`Offending field(s): ${shown.join(", ")}${extra}.`);
+  }
+  parts.push("Fix the flagged field(s) or re-scaffold the affected node, then re-run.");
+  return parts.join(" ");
+}
+function checkForwardMigration(rawWorkflow) {
+  try {
+    getMigrationChain(runtimeMigrations, String(rawWorkflow.version ?? ""), runtimeVersion);
+  } catch {
+    return { ok: true };
+  }
+  const { tracker, fieldPaths } = captureMigrationIssues();
+  const result = migrateWorkflowToFloor(runtimeMigrations, rawWorkflow, runtimeVersion, minimumSupportedVersion, tracker);
+  if (!result.error)
+    return { ok: true };
+  const paths = fieldPaths();
+  return {
+    ok: false,
+    step: result.error.step,
+    rawMessage: result.error.message,
+    message: formatMigrationFailureMessage(result.error.step, result.error.message, paths),
+    fieldPaths: paths
+  };
+}
+
+export { captureMigrationIssues, formatMigrationFailureMessage, checkForwardMigration };
+
+//# debugId=0E30F23E96D10D1C64756E2164756E21

package/dist/packager-tool-2wefykg9.js

@@ -0,0 +1,106 @@
+// src/services/connector-node-types.ts
+function isConnectorTriggerType(nodeType) {
+  return nodeType.startsWith("uipath.connector.trigger");
+}
+function isConnectorWaitForEventType(nodeType) {
+  return nodeType.startsWith("uipath.connector.event");
+}
+function isEventDrivenConnectorType(nodeType) {
+  return isConnectorTriggerType(nodeType) || isConnectorWaitForEventType(nodeType);
+}
+
+// src/services/node-validators/cross-node-binding-validator.ts
+var IDENTIFIER_ROOT_RE = /(?<![.\w$])([A-Za-z_$][\w$]*)\.(?!\.)/g;
+function findCrossNodeBindingReferences(value, nodeIds) {
+  if (nodeIds.size === 0)
+    return [];
+  const trimmed = value.trimStart();
+  if (!trimmed.startsWith("=js:"))
+    return [];
+  const body = trimmed.slice(4);
+  const referenced = new Set;
+  const fixedBody = body.replace(IDENTIFIER_ROOT_RE, (match, identifier) => {
+    if (!nodeIds.has(identifier))
+      return match;
+    referenced.add(identifier);
+    return `$vars.${match}`;
+  });
+  if (referenced.size === 0)
+    return [];
+  const fixedValue = `=js:${fixedBody}`;
+  return [...referenced].map((nodeId) => ({ nodeId, fixedValue }));
+}
+function crossNodeBindingMessage(originalValue, ref) {
+  return `Expression "${originalValue}" references node "${ref.nodeId}" without the "$vars." prefix — ` + `cross-node outputs resolve to undefined at runtime (the bare identifier reads as an ` + `undeclared local, not the runtime variable). Use "${ref.fixedValue}" instead. ` + "See uipath-maestro-flow skill — node-output-wiring.md (FPD-538).";
+}
+function scanContainerForCrossNodeBindings(obj, path, nodeIds, severity, issues) {
+  if (typeof obj === "string") {
+    for (const ref of findCrossNodeBindingReferences(obj, nodeIds)) {
+      issues.push({
+        path,
+        severity,
+        message: crossNodeBindingMessage(obj, ref)
+      });
+    }
+    return;
+  }
+  if (Array.isArray(obj)) {
+    for (let i = 0;i < obj.length; i++) {
+      scanContainerForCrossNodeBindings(obj[i], `${path}[${i}]`, nodeIds, severity, issues);
+    }
+    return;
+  }
+  if (obj && typeof obj === "object") {
+    for (const [key, value] of Object.entries(obj)) {
+      scanContainerForCrossNodeBindings(value, `${path}.${key}`, nodeIds, severity, issues);
+    }
+  }
+}
+var PARAMETER_CONTAINER_KEYS = [
+  "bodyParameters",
+  "queryParameters",
+  "pathParameters"
+];
+function scanDetailForCrossNodeBindings(detail, nodeIds, severity = "warning") {
+  if (!detail || nodeIds.size === 0)
+    return [];
+  const issues = [];
+  for (const containerKey of PARAMETER_CONTAINER_KEYS) {
+    const container = detail[containerKey];
+    if (!container || typeof container !== "object" || Array.isArray(container)) {
+      continue;
+    }
+    scanContainerForCrossNodeBindings(container, `detail.${containerKey}`, nodeIds, severity, issues);
+  }
+  return issues;
+}
+var crossNodeBindingValidator = {
+  id: "cross-node-binding",
+  appliesTo: (node) => {
+    const t = node.type;
+    if (!t)
+      return false;
+    if (isEventDrivenConnectorType(t))
+      return false;
+    return t.startsWith("uipath.connector.") || t === "core.action.http" || t === "core.action.http.v2";
+  },
+  validate: (node, context) => {
+    const nodeIds = context.nodeIds ?? new Set;
+    if (nodeIds.size === 0)
+      return [];
+    const rawDetail = node.inputs?.detail;
+    if (!rawDetail || typeof rawDetail !== "object" || Array.isArray(rawDetail)) {
+      return [];
+    }
+    const severity = context.strictBindings ? "error" : "warning";
+    const issues = scanDetailForCrossNodeBindings(rawDetail, nodeIds, severity);
+    return issues.map((issue) => ({
+      ...issue,
+      path: `nodes[${node.id}].inputs.${issue.path}`
+    }));
+  }
+};
+
+export { isConnectorTriggerType, isConnectorWaitForEventType, isEventDrivenConnectorType, scanDetailForCrossNodeBindings, crossNodeBindingValidator };
+
+//# debugId=27B3D26268A7A36764756E2164756E21

package/dist/{packager-tool-sf18719z.js → packager-tool-38ydychm.js}

@@ -1,28 +1,32 @@
-import {
-  VALID_PROJECT_NAME_REGEX,
-  nodeModuleRegistry,
-  writeFlowWorkflow
-} from "./packager-tool-djagtpkt.js";
 import {
   prepareProjectLocation,
   tryRegisterProjectInParentSolution
-} from "./packager-tool-0sz8se22.js";
+} from "./packager-tool-cabxfk33.js";
+import {
+  writeFlowWorkflow
+} from "./packager-tool-h2qfyjf1.js";
+import {
+  createWorkflow
+} from "./packager-tool-tn5e7wnb.js";
+import {
+  VALID_PROJECT_NAME_REGEX
+} from "./packager-tool-eypvc2kv.js";
 import {
   catchError
-} from "./packager-tool-cvwr40ax.js";
+} from "./packager-tool-226mh80j.js";
 import {
   getFileSystem
-} from "./packager-tool-1cb0d5e0.js";
+} from "./packager-tool-0v3s8r01.js";
 import {
-  createWorkflow
-} from "./packager-tool-gasyxww9.js";
+  nodeModuleRegistry
+} from "./packager-tool-p9stswjj.js";
 import {
   __require
-} from "./packager-tool-wckvcay0.js";
+} from "./packager-tool-1yh8g550.js";
 
 // src/services/project-artifacts.ts
 async function ensureProjectArtifacts(args) {
-  const { addProjectArtifactsToSolutionAsync } = await import("./index-dhcd9b82.js");
+  const { addProjectArtifactsToSolutionAsync } = await import("./index-d5ddwgr3.js");
   return addProjectArtifactsToSolutionAsync(args);
 }
 
@@ -105,4 +109,4 @@ async function maybeGenerateProjectArtifacts(registration, projectName) {
 
 export { flowInitAsync };
 
-//# debugId=5364B2B1CFDDFE8864756E2164756E21
+//# debugId=EBC554606544E02D64756E2164756E21

package/dist/packager-tool-48f4ekg5.js

@@ -0,0 +1,262 @@
+import {
+  ensureDirectory
+} from "./packager-tool-gcy5q3jv.js";
+import {
+  buildInlineAgentContract,
+  isInlineAgentNodeType,
+  operateRuntimeOptions,
+  readInlineAgentSource
+} from "./packager-tool-1r8c83fc.js";
+import {
+  catchError,
+  logger
+} from "./packager-tool-226mh80j.js";
+import {
+  EntryPointType,
+  ProjectType,
+  generateBindingsJson,
+  generateEntryPointsJson,
+  generateOperateJson,
+  getBindingResources,
+  getEntryPoints,
+  isConversationalOrVoiceAgentNodeType,
+  mergeBindingResources
+} from "./packager-tool-m5qfverj.js";
+
+// src/services/packaging-utils.ts
+function fileNodesToPackagingNodes(nodes) {
+  return nodes.map((node) => ({
+    id: node.id,
+    type: node.type,
+    typeVersion: node.typeVersion ?? "1.0",
+    display: node.display,
+    inputs: node.inputs,
+    outputs: node.outputs,
+    ...node.model ? { model: node.model } : {}
+  }));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toResourceList(value) {
+  if (!Array.isArray(value))
+    return;
+  const resources = value.filter(isRecord);
+  return resources.length === value.length ? resources : undefined;
+}
+function normalizePackagingBindingsJson(value) {
+  if (!isRecord(value))
+    return;
+  const resources = toResourceList(value.resources);
+  if (!resources)
+    return;
+  return {
+    ...value,
+    version: typeof value.version === "string" ? value.version : "2.0",
+    resources
+  };
+}
+function emptyPackagingBindingsJson() {
+  return { version: "2.0", resources: [] };
+}
+function mergePackagingBindingsJson(bindingsJsons) {
+  const first = bindingsJsons.find((bindingsJson) => bindingsJson !== undefined);
+  return {
+    ...first ?? emptyPackagingBindingsJson(),
+    resources: mergeBindingResources(bindingsJsons.flatMap((bindingsJson) => bindingsJson?.resources ?? []))
+  };
+}
+var inlineAgentPackagerLogger = {
+  debug: (message) => logger.debug(message),
+  info: (message) => logger.info(message),
+  warn: (message) => logger.warn(message),
+  error: (message) => logger.error(message),
+  progress: (message) => logger.info(message),
+  log: (message, level) => {
+    if (level === "Error" /* Error */)
+      logger.error(message);
+    else if (level === "Warning" /* Warn */)
+      logger.warn(message);
+    else if (level === "Debug" /* Debug */)
+      logger.debug(message);
+    else
+      logger.info(message);
+  },
+  logMessage: (message) => inlineAgentPackagerLogger.log(message.message, message.logLevel)
+};
+async function createInlineAgentContract(fs, agentDir) {
+  const outputPath = fs.path.join(fs.env.tmpdir(), `.inline-agent-contract-${crypto.randomUUID()}`);
+  await fs.mkdir(outputPath);
+  try {
+    const built = await buildInlineAgentContract({
+      fileSystem: fs,
+      logger: inlineAgentPackagerLogger,
+      projectPath: agentDir,
+      outputPath
+    });
+    const bindingsJson = normalizePackagingBindingsJson(built.bindingsJson);
+    if (!bindingsJson) {
+      throw new Error("Agent packager returned an invalid binding contract");
+    }
+    return { agentJson: built.agentJson, bindingsJson };
+  } finally {
+    const [cleanupError] = await catchError(fs.rm(outputPath, { recursive: true }));
+    if (cleanupError) {
+      logger.debug(`Could not remove inline-agent contract directory ${outputPath}: ${cleanupError.message}`);
+    }
+  }
+}
+async function inlineAgentExists(fs, projectDir, source) {
+  const agentJsonPath = fs.path.join(projectDir, source, "agent.json");
+  return fs.exists(agentJsonPath);
+}
+async function packageInlineAgents(fs, projectDir, nodes) {
+  const result = [];
+  for (const node of nodes) {
+    if (!isInlineAgentNodeType(node.type))
+      continue;
+    const source = readInlineAgentSource(node);
+    if (!source)
+      continue;
+    if (/[/\\.]/.test(source))
+      continue;
+    if (!await inlineAgentExists(fs, projectDir, source))
+      continue;
+    const contract = await createInlineAgentContract(fs, fs.path.join(projectDir, source));
+    const inputSchema = contract.agentJson.inputSchema ?? {
+      type: "object",
+      properties: {}
+    };
+    const outputSchema = contract.agentJson.outputSchema ?? {
+      type: "object",
+      properties: {}
+    };
+    result.push({
+      source,
+      entryPoint: {
+        filePath: `content/${source}/agent.json`,
+        uniqueId: contract.agentJson.projectId ?? source,
+        type: EntryPointType.Agent,
+        input: inputSchema,
+        output: outputSchema,
+        displayName: contract.agentJson.name ?? "Agent"
+      },
+      agentJson: contract.agentJson,
+      bindingsJson: contract.bindingsJson
+    });
+    logger.info(`Packaged inline agent "${source}" for entry-points`);
+  }
+  return result;
+}
+async function stageInlineAgentPackageFiles(fs, sourceProjectPath, stagingProjectDir, inlineAgents, formatLogMessage) {
+  for (const agent of inlineAgents) {
+    const srcDir = fs.path.join(sourceProjectPath, agent.source);
+    const destDir = fs.path.join(stagingProjectDir, agent.source);
+    if (fs.path.resolve(srcDir) !== fs.path.resolve(destDir) && await fs.exists(srcDir)) {
+      await fs.copyDirectory(srcDir, destDir);
+    }
+    const agentBuilderDir = fs.path.join(destDir, ".agent-builder");
+    await ensureDirectory(fs, agentBuilderDir);
+    await fs.writeFile(fs.path.join(agentBuilderDir, "agent.json"), JSON.stringify({
+      ...agent.agentJson,
+      resources: agent.agentJson.resources ?? [],
+      features: agent.agentJson.features ?? []
+    }, null, 2));
+    await fs.writeFile(fs.path.join(agentBuilderDir, "bindings.json"), `${JSON.stringify(agent.bindingsJson ?? emptyPackagingBindingsJson(), null, 2)}
+`);
+    logger.info(formatLogMessage(agent.source));
+  }
+}
+function buildInlineAgentDescriptors(nodes) {
+  const out = [];
+  for (const node of nodes) {
+    if (!isInlineAgentNodeType(node.type))
+      continue;
+    const source = readInlineAgentSource(node);
+    if (!source)
+      continue;
+    const label = node.display?.label ?? "Agent";
+    out.push({
+      name: label,
+      agentProjectId: source,
+      isConversational: isConversationalOrVoiceAgentNodeType(node.type),
+      entryPointPath: `${source}/agent.json`
+    });
+  }
+  return out;
+}
+async function writePackagingArtifacts(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions = [], options = {}) {
+  const { entryPoints } = await writePackagingArtifactsDetailed(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions, options);
+  return entryPoints;
+}
+async function writePackagingArtifactsDetailed(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions = [], options = {}) {
+  const flowEntryPoints = getEntryPoints(bpmnFileName, packagingNodes, variables, definitions, ProjectType.Flow);
+  const entryPoints = [
+    ...flowEntryPoints,
+    ...options.additionalEntryPoints ?? []
+  ];
+  await fs.writeFile(fs.path.join(projectDir, "entry-points.json"), `${JSON.stringify(generateEntryPointsJson(entryPoints), null, 2)}
+`);
+  const bindingResources = getBindingResources(packagingNodes, bindings, definitions);
+  const bindingsJson = normalizePackagingBindingsJson(generateBindingsJson(bindingResources)) ?? emptyPackagingBindingsJson();
+  const stagedBindingsJson = mergePackagingBindingsJson([
+    bindingsJson,
+    ...options.additionalBindingsJsons ?? []
+  ]);
+  await fs.writeFile(fs.path.join(projectDir, "bindings_v2.json"), `${JSON.stringify(stagedBindingsJson, null, 2)}
+`);
+  const mainEntryPoint = `/${bpmnFileName}#${startEventId}`;
+  const operateJson = generateOperateJson(projectId, mainEntryPoint, operateRuntimeOptions(packagingNodes));
+  await fs.writeFile(fs.path.join(projectDir, "operate.json"), `${JSON.stringify(operateJson, null, 2)}
+`);
+  const packageDescriptorJson = options.packageDescriptorJson ?? {
+    $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
+    files: {
+      "operate.json": "operate.json",
+      "entry-points.json": "entry-points.json",
+      "bindings.json": "bindings_v2.json",
+      [bpmnFileName]: bpmnFileName,
+      ...flowFileName ? { [flowFileName]: flowFileName } : {}
+    }
+  };
+  await fs.writeFile(fs.path.join(projectDir, "package-descriptor.json"), `${JSON.stringify(packageDescriptorJson, null, 2)}
+`);
+  return { entryPoints, bindingsJson: stagedBindingsJson };
+}
+function backfillNodeModelsFromDefinitions(nodes, definitions) {
+  if (definitions.length === 0)
+    return nodes;
+  const definitionByType = new Map;
+  for (const def of definitions) {
+    if (def?.nodeType)
+      definitionByType.set(def.nodeType, def);
+  }
+  return nodes.map((n) => {
+    if (n.model)
+      return n;
+    const def = definitionByType.get(n.type);
+    if (!def?.model)
+      return n;
+    return { ...n, model: def.model };
+  });
+}
+async function regenerateBindingsFile(fs, flowFilePath) {
+  const absolutePath = fs.path.resolve(flowFilePath);
+  const projectDir = fs.path.dirname(absolutePath);
+  const content = await fs.readFile(absolutePath, "utf-8");
+  if (!content) {
+    throw new Error(`Could not read .flow file at ${absolutePath}`);
+  }
+  const [parseErr, flowData] = catchError(() => JSON.parse(content));
+  if (parseErr) {
+    throw new Error(`Failed to parse .flow file at ${absolutePath}: ${parseErr.message}`);
+  }
+  const packagingNodes = backfillNodeModelsFromDefinitions(fileNodesToPackagingNodes(flowData.nodes ?? []), flowData.definitions ?? []);
+  const bindingResources = getBindingResources(packagingNodes, flowData.bindings ?? [], flowData.definitions ?? []);
+  await fs.writeFile(fs.path.join(projectDir, "bindings_v2.json"), `${JSON.stringify(generateBindingsJson(bindingResources), null, 2)}
+`);
+}
+
+export { fileNodesToPackagingNodes, packageInlineAgents, stageInlineAgentPackageFiles, buildInlineAgentDescriptors, writePackagingArtifacts, writePackagingArtifactsDetailed, regenerateBindingsFile };
+
+//# debugId=D58F45C9E111C57064756E2164756E21

package/dist/{packager-tool-7yjpwj92.js → packager-tool-4hx14snw.js}

@@ -1,50 +1,3 @@
-// ../packager/packager-core/src/services/tools-factory-repository.ts
-class ToolsFactoryRepository {
-  projectFactoryMap = new Map;
-  solutionFactory = null;
-  registerProjectToolFactory(factory) {
-    for (const type of factory.supportedTypes) {
-      const existing = this.projectFactoryMap.get(type);
-      if (existing) {
-        if (existing.constructor?.name !== factory.constructor?.name) {
-          console.warn(`Tool factory conflict for project type '${type}': ` + `'${existing.constructor?.name}' already registered, ` + `ignoring '${factory.constructor?.name}'.`);
-        }
-        continue;
-      }
-      this.projectFactoryMap.set(type, factory);
-    }
-  }
-  registerSolutionToolFactory(factory) {
-    this.solutionFactory = factory;
-  }
-  getSolutionToolFactory() {
-    if (!this.solutionFactory) {
-      throw new Error("No solution tool factory is registered");
-    }
-    return this.solutionFactory;
-  }
-  canHandleProject(projectType) {
-    return this.projectFactoryMap.has(projectType);
-  }
-  getProjectToolFactory(projectType) {
-    const factory = this.projectFactoryMap.get(projectType);
-    if (!factory) {
-      throw new Error(`No tool factory found for project type '${projectType}'`);
-    }
-    return factory;
-  }
-  reset() {
-    this.projectFactoryMap.clear();
-    this.solutionFactory = null;
-  }
-}
-var REGISTRY_KEY = Symbol.for("@uipath/solutionpackager-tool-core/toolsFactoryRepository");
-var _global = globalThis;
-if (!_global[REGISTRY_KEY]) {
-  _global[REGISTRY_KEY] = new ToolsFactoryRepository;
-}
-var toolsFactoryRepository = _global[REGISTRY_KEY];
-
 // ../packager/packager-core/src/filesystem/path.ts
 class Path {
   static normalize(path) {
@@ -168,6 +121,54 @@ async function ensureProjectId(projectPath, fs) {
   }
   return crypto.randomUUID();
 }
+
+// ../packager/packager-core/src/services/tools-factory-repository.ts
+class ToolsFactoryRepository {
+  projectFactoryMap = new Map;
+  solutionFactory = null;
+  registerProjectToolFactory(factory) {
+    for (const type of factory.supportedTypes) {
+      const existing = this.projectFactoryMap.get(type);
+      if (existing) {
+        if (existing.constructor?.name !== factory.constructor?.name) {
+          console.warn(`Tool factory conflict for project type '${type}': ` + `'${existing.constructor?.name}' already registered, ` + `ignoring '${factory.constructor?.name}'.`);
+        }
+        continue;
+      }
+      this.projectFactoryMap.set(type, factory);
+    }
+  }
+  registerSolutionToolFactory(factory) {
+    this.solutionFactory = factory;
+  }
+  getSolutionToolFactory() {
+    if (!this.solutionFactory) {
+      throw new Error("No solution tool factory is registered");
+    }
+    return this.solutionFactory;
+  }
+  canHandleProject(projectType) {
+    return this.projectFactoryMap.has(projectType);
+  }
+  getProjectToolFactory(projectType) {
+    const factory = this.projectFactoryMap.get(projectType);
+    if (!factory) {
+      const known = [...this.projectFactoryMap.keys()].join(", ");
+      throw new Error(`Cannot pack project type '${projectType}': no packager is installed for it. ` + `Project types that can be packed: ${known || "none"}.`);
+    }
+    return factory;
+  }
+  reset() {
+    this.projectFactoryMap.clear();
+    this.solutionFactory = null;
+  }
+}
+var REGISTRY_KEY = Symbol.for("@uipath/solutionpackager-tool-core/toolsFactoryRepository");
+var _global = globalThis;
+if (!_global[REGISTRY_KEY]) {
+  _global[REGISTRY_KEY] = new ToolsFactoryRepository;
+}
+var toolsFactoryRepository = _global[REGISTRY_KEY];
 // ../packager/packager-core/src/i18n/types.ts
 function isPluralForm(value) {
   return typeof value === "object" && value !== null && "other" in value;
@@ -993,4 +994,4 @@ I18nManager.registerTranslations("zu", zu);
 I18nManager.setLocale("en");
 export { ensureProjectId, toolsFactoryRepository };
 
-//# debugId=E7E9643153503BFD64756E2164756E21
+//# debugId=4DB39423849BB6D564756E2164756E21