@uipath/case-tool 1.203.0-preview.212 → 1.204.0-preview.211

package/dist/strict-case-rules-ksy8q7pg.js

@@ -0,0 +1,731 @@
+import {
+  ACTIVITY_TYPE_ID_PATH,
+  activityTypeIdMessage,
+  contextEntry,
+  missingContextKeys,
+  readActivityTypeId
+} from "./packager-tool-cv05dwac.js";
+import {
+  BINDING_REFERENCE_PREFIX,
+  NAME_BOUND_TASK_TYPES,
+  RESOLVED_IDENTITY_KEYS
+} from "./packager-tool-d7jjng8a.js";
+import {
+  JINT_GLOBALS
+} from "./packager-tool-bfgdz1zh.js";
+import {
+  byCodeUnit
+} from "./packager-tool-5qp9xza1.js";
+import"./packager-tool-1yh8g550.js";
+
+// src/services/strict-connection-binding.ts
+var CONNECTION_RESOURCE = "Connection";
+var FOLDER_KEY_ATTRIBUTE = "folderKey";
+var READ_FIELDS = [
+  { field: "id", mustBeNonEmpty: false },
+  { field: "resourceKey", mustBeNonEmpty: true },
+  { field: "propertyAttribute", mustBeNonEmpty: false }
+];
+var EMPTY_FIELD_HARM = {
+  id: "A task points at a binding as `=bindings.<id>`, so an entry with an empty `id` is written into the task as `=bindings.` — a reference that resolves to nothing, with every check still passing.",
+  propertyAttribute: "The generated entry reads each value by its `propertyAttribute`, so an empty one is never read: whatever this binding carries — a connection id, a folder key — silently contributes nothing to `bindings_v2.json`."
+};
+var nonEmptyString = (value) => typeof value === "string" && value.trim() !== "";
+var checkConnectionBindings = (parsed) => {
+  const bindings = Array.isArray(parsed.bindings) ? parsed.bindings : [];
+  const issues = [];
+  bindings.forEach((entry, index) => {
+    if (typeof entry !== "object" || entry === null)
+      return;
+    const binding = entry;
+    if (binding.resource !== CONNECTION_RESOURCE)
+      return;
+    const path = `bindings[${index}]`;
+    const label = nonEmptyString(binding.name) ? ` ("${String(binding.name)}")` : "";
+    const missing = READ_FIELDS.filter(({ field, mustBeNonEmpty }) => typeof binding[field] !== "string" || mustBeNonEmpty && !nonEmptyString(binding[field])).map(({ field }) => field);
+    const badDefault = binding.default !== undefined && typeof binding.default !== "string";
+    if (missing.length > 0 || badDefault) {
+      const parts = [
+        ...missing.map((field) => `\`${field}\``),
+        badDefault && "a non-string `default`"
+      ].filter((part) => part !== false);
+      issues.push({
+        code: "STRICT_CONNECTION_BINDING_DROPPED",
+        path,
+        severity: "error",
+        message: `This \`Connection\` binding${label} has ` + `${parts.join(", ")}. \`bindings_v2.json\` is generated by ` + "grouping the bindings array, and a binding missing any " + "field the grouping reads is skipped without an error — so " + "the connection never reaches the file, and " + "`uip solution resources refresh` has nothing to resolve."
+      });
+      return;
+    }
+    const empty = READ_FIELDS.map(({ field }) => field).filter((field) => binding[field] === "");
+    for (const field of empty) {
+      issues.push({
+        code: "STRICT_CONNECTION_BINDING_FIELD_EMPTY",
+        path: `${path}.${field}`,
+        severity: "error",
+        message: `This \`Connection\` binding${label} has an empty ` + `\`${field}\`. ${EMPTY_FIELD_HARM[field] ?? ""} The entry ` + "is still grouped into `bindings_v2.json` — only " + "`resourceKey` has to be non-empty for that — so nothing " + "else reports it."
+      });
+    }
+    if (empty.length > 0)
+      return;
+    if (binding.propertyAttribute !== FOLDER_KEY_ATTRIBUTE)
+      return;
+    if (nonEmptyString(binding.default))
+      return;
+    issues.push({
+      code: "STRICT_CONNECTION_FOLDER_KEY_NO_DEFAULT",
+      path: `${path}.default`,
+      severity: "error",
+      message: `This connection's \`${FOLDER_KEY_ATTRIBUTE}\` binding${label} ` + "carries no `default`. The generated entry takes the folder " + "key from that field and omits the property when it is " + "missing, so the connection ships with its id and no folder — " + "and unlike `ConnectionId`, which falls back to the binding's " + "`resourceKey`, there is nothing to fall back to here."
+    });
+  });
+  return issues;
+};
+
+// src/services/strict-js-source.ts
+import { Script } from "node:vm";
+var JS_PREFIX = "=js:";
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+var forEachJsExpression = (value, path, visit) => {
+  if (typeof value === "string") {
+    if (value.startsWith(JS_PREFIX)) {
+      visit(value.slice(JS_PREFIX.length), path, value);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => {
+      forEachJsExpression(entry, `${path}[${index}]`, visit);
+    });
+    return;
+  }
+  const record = asRecord(value);
+  if (!record)
+    return;
+  for (const [key, entry] of Object.entries(record)) {
+    forEachJsExpression(entry, `${path}.${key}`, visit);
+  }
+};
+var jsSyntaxError = (source) => {
+  try {
+    new Script(source);
+    return null;
+  } catch (error) {
+    return error instanceof SyntaxError ? error.message : null;
+  }
+};
+var interpolationEnd = (source, from) => {
+  let index = from;
+  let depth = 1;
+  while (index < source.length && depth > 0) {
+    const char = source[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      index += 1;
+      while (index < source.length && source[index] !== char) {
+        index += source[index] === "\\" ? 2 : 1;
+      }
+      index += 1;
+      continue;
+    }
+    if (char === "/" && source[index + 1] === "/") {
+      while (index < source.length && source[index] !== `
+`)
+        index += 1;
+      continue;
+    }
+    if (char === "/" && source[index + 1] === "*") {
+      index += 2;
+      while (index + 1 < source.length && !(source[index] === "*" && source[index + 1] === "/")) {
+        index += 1;
+      }
+      index += 2;
+      continue;
+    }
+    if (char === "{")
+      depth += 1;
+    else if (char === "}")
+      depth -= 1;
+    index += 1;
+  }
+  return index;
+};
+var stripJsLiterals = (source) => {
+  const out = [];
+  let index = 0;
+  while (index < source.length) {
+    const char = source[index];
+    if (char === '"' || char === "'") {
+      index += 1;
+      while (index < source.length && source[index] !== char) {
+        index += source[index] === "\\" ? 2 : 1;
+      }
+      index += 1;
+      out.push(" ");
+      continue;
+    }
+    if (char === "`") {
+      index += 1;
+      while (index < source.length && source[index] !== "`") {
+        if (source[index] === "\\") {
+          index += 2;
+          continue;
+        }
+        if (source[index] === "$" && source[index + 1] === "{") {
+          const end = interpolationEnd(source, index + 2);
+          out.push(` ${stripJsLiterals(source.slice(index + 2, end - 1))} `);
+          index = end;
+          continue;
+        }
+        index += 1;
+      }
+      index += 1;
+      out.push(" ");
+      continue;
+    }
+    if (char === "/" && source[index + 1] === "/") {
+      while (index < source.length && source[index] !== `
+`)
+        index += 1;
+      continue;
+    }
+    if (char === "/" && source[index + 1] === "*") {
+      index += 2;
+      while (index + 1 < source.length && !(source[index] === "*" && source[index + 1] === "/")) {
+        index += 1;
+      }
+      index += 2;
+      out.push(" ");
+      continue;
+    }
+    out.push(char);
+    index += 1;
+  }
+  return out.join("");
+};
+
+// src/services/strict-js-scope.ts
+var EXPRESSION_NAMESPACES = new Set([
+  "bindings",
+  "datafabric",
+  "outputs",
+  "result",
+  "this",
+  "vars",
+  "iterator",
+  "metadata",
+  "orchestrator",
+  "instanceglobals",
+  "runtime",
+  "senderinfo"
+]);
+var AMBIENT_NAMES = new Set([
+  ...JINT_GLOBALS,
+  "atob",
+  "btoa",
+  "async",
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "in",
+  "instanceof",
+  "let",
+  "new",
+  "null",
+  "of",
+  "return",
+  "super",
+  "switch",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "yield"
+]);
+var ROOT_IDENTIFIER = /(?<![.$\w])([A-Za-z_$][\w$]*)/g;
+var LOCAL_BINDING = /=>|\bfunction\b|\b(?:var|let|const)\s|\bcatch\s*\(/;
+var UNSCANNABLE = /\//;
+var unknownIdentifiers = (source) => {
+  if (jsSyntaxError(source) !== null)
+    return [];
+  const code = stripJsLiterals(source);
+  if (LOCAL_BINDING.test(code))
+    return [];
+  if (UNSCANNABLE.test(code))
+    return [];
+  const found = [];
+  for (const match of code.matchAll(ROOT_IDENTIFIER)) {
+    const name = match[1];
+    if (EXPRESSION_NAMESPACES.has(name) || AMBIENT_NAMES.has(name))
+      continue;
+    const after = code.slice(match.index + name.length);
+    const before = code.slice(0, match.index).trimEnd();
+    const key = before.endsWith("{") || before.endsWith(",") || before === "";
+    if (key && /^\s*:/.test(after) && !/^\s*::/.test(after))
+      continue;
+    if (!found.includes(name))
+      found.push(name);
+  }
+  return found;
+};
+var checkJsExpressionScope = (parsed) => {
+  const issues = [];
+  forEachJsExpression(parsed, "(root)", (source, path, raw) => {
+    const unknown = unknownIdentifiers(source);
+    if (unknown.length === 0)
+      return;
+    const names = unknown.map((name) => `\`${name}\``).join(", ");
+    issues.push({
+      code: "STRICT_JS_UNKNOWN_IDENTIFIER",
+      path,
+      severity: "error",
+      message: `This \`=js:\` expression reads ${names}, which nothing puts ` + "in scope. The runtime evaluates it as JavaScript against the " + "case data, so an undeclared name is a ReferenceError on the " + "first evaluation and the element it belongs to produces no " + "verdict. A case variable is reached through its namespace " + `(\`vars.${unknown[0]}\`), and a literal string needs its ` + `quotes (\`=js:'${unknown[0]}'\`). Readable namespaces: ` + `${[...EXPRESSION_NAMESPACES].sort(byCodeUnit).join(", ")}. Offending ` + `text: ${JSON.stringify(raw.slice(0, 70))}`
+    });
+  });
+  return issues;
+};
+
+// src/services/strict-case-rules.ts
+var FORMAL_ARG_ID = /^v[A-Za-z0-9]{8}$/;
+var asRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+var asArray = (value) => Array.isArray(value) ? value : [];
+var nodeType = (node) => typeof node.type === "string" ? node.type : "";
+var isStage = (node) => nodeType(node).startsWith("case-management:Stage") || nodeType(node) === "case-management:Stage";
+var checkStagesHaveTasks = (nodes) => {
+  const issues = [];
+  for (const node of nodes) {
+    if (!isStage(node))
+      continue;
+    const data = asRecord2(node.data);
+    const lanes = asArray(data?.tasks);
+    const taskCount = lanes.reduce((total, lane) => total + asArray(lane).length, 0);
+    if (taskCount > 0)
+      continue;
+    const id = typeof node.id === "string" ? node.id : "?";
+    issues.push({
+      code: "STRICT_STAGE_NO_TASKS",
+      path: `nodes[${id}].data.tasks`,
+      severity: "error",
+      message: `Stage "${id}" declares no tasks. A stage with empty task ` + "lanes deploys and then has nothing to run, so the case " + "enters it and stops."
+    });
+  }
+  return issues;
+};
+var checkJsExpressionsParse = (parsed) => {
+  const issues = [];
+  forEachJsExpression(parsed, "(root)", (source, path, raw) => {
+    const failure = jsSyntaxError(source);
+    if (failure === null)
+      return;
+    const escaped = source.replace(/\r\n|\r|\n/g, String.raw`\n`);
+    const rawLineBreak = escaped !== source && jsSyntaxError(escaped) === null;
+    issues.push({
+      code: "STRICT_JS_EXPRESSION_INVALID",
+      path,
+      severity: "error",
+      message: `This \`=js:\` expression does not parse: ${failure}. The ` + "runtime evaluates it as JavaScript, so the element faults on " + "its first evaluation." + (rawLineBreak ? " It carries a raw line break: write `\\\\n` in the JSON " + "so the JavaScript source carries `\\n`." : "") + ` Offending text: ${JSON.stringify(raw.slice(0, 70))}`
+    });
+  });
+  return issues;
+};
+var argumentCompanionIssues = (variable, name, path, triggerIds) => {
+  const at = variable.elementId;
+  if (typeof at !== "string" || !triggerIds.has(at))
+    return [];
+  return ["default", "custom"].filter((key) => variable[key] !== undefined).map((key) => ({
+    code: "STRICT_ARGUMENT_COMPANION_FIELD",
+    path: `${path}.${key}`,
+    severity: "error",
+    message: `Argument companion "${name}" carries ` + `"${key}". A companion on a trigger is the ` + "argument half of the pair: the formal slot in " + "`variables.inputs[]` carries the default, and " + "`custom` lists a variable as case data, so neither " + `belongs here. Remove "${key}" from this entry ` + "and keep the rest, including the JobAttachment " + "`body` a file argument carries."
+  }));
+};
+var checkVariableContract = (variables, triggerIds) => {
+  const issues = [];
+  for (const slot of ["inputs", "outputs", "inputOutputs"]) {
+    asArray(variables?.[slot]).forEach((entry, index) => {
+      const variable = asRecord2(entry);
+      if (!variable)
+        return;
+      const name = typeof variable.name === "string" ? variable.name : `#${index}`;
+      const path = `variables.${slot}[${name}]`;
+      const id = variable.id;
+      if (slot !== "inputOutputs") {
+        if (typeof id !== "string" || !FORMAL_ARG_ID.test(id)) {
+          issues.push({
+            code: "STRICT_FORMAL_ARG_ID",
+            path: `${path}.id`,
+            severity: "error",
+            message: `Formal argument "${name}" has id ` + `"${String(id)}", which is not the generated ` + 'form "v" + 8 characters. An id copied from the ' + "name collides across renames and does not match " + "what the converter emits."
+          });
+        }
+      }
+      if (slot === "inputOutputs") {
+        issues.push(...argumentCompanionIssues(variable, name, path, triggerIds));
+      }
+      if (variable.default !== undefined && typeof variable.default !== "string") {
+        issues.push({
+          code: "STRICT_DEFAULT_NOT_STRING",
+          path: `${path}.default`,
+          severity: "error",
+          message: `Default for "${name}" is a ` + `${Array.isArray(variable.default) ? "array" : typeof variable.default} ` + "and must be a JSON string. The converter drops " + "non-string defaults without saying so, so the value " + "silently disappears from entry-points.json."
+        });
+      }
+    });
+  }
+  return issues;
+};
+var checkInputOutputCompanions = (variables, nodes) => {
+  const issues = [];
+  const companions = new Set(asArray(variables?.inputOutputs).map((entry) => asRecord2(entry)?.name).filter((name) => typeof name === "string"));
+  const unbound = (name) => !companions.has(name);
+  asArray(variables?.inputs).forEach((entry) => {
+    const variable = asRecord2(entry);
+    const name = variable?.name;
+    if (typeof name !== "string" || !unbound(name))
+      return;
+    issues.push({
+      code: "STRICT_INPUTOUTPUTS_COMPANION",
+      path: `variables.inputs[${name}]`,
+      severity: "error",
+      message: `In-argument "${name}" has no entry of the same name in ` + "variables.inputOutputs[]. The companion is what carries the " + "binding, so without it the argument is declared and never " + "bound."
+    });
+  });
+  for (const node of nodes) {
+    const nodeId = typeof node.id === "string" ? node.id : "?";
+    const data = asRecord2(node.data);
+    for (const lane of asArray(data?.tasks)) {
+      for (const task of asArray(lane)) {
+        const taskRecord = asRecord2(task);
+        if (!taskRecord)
+          continue;
+        const taskId = typeof taskRecord.id === "string" ? taskRecord.id : "?";
+        for (const output of asArray(asRecord2(taskRecord.data)?.outputs)) {
+          const record = asRecord2(output);
+          if (record?.custom !== true)
+            continue;
+          const variableName = record.var;
+          if (typeof variableName !== "string" || !unbound(variableName)) {
+            continue;
+          }
+          const label = typeof record.name === "string" ? record.name : variableName;
+          issues.push({
+            code: "STRICT_INPUTOUTPUTS_COMPANION",
+            path: `nodes[${nodeId}].data.tasks[${taskId}].data.outputs[${label}]`,
+            severity: "error",
+            message: `Custom output "${label}" writes to ` + `"${variableName}", which has no entry in ` + "variables.inputOutputs[]. Without the companion " + "the value has nowhere to land."
+          });
+        }
+      }
+    }
+  }
+  return issues;
+};
+var checkConnectorRuleContext = (nodes, bindings) => {
+  const issues = [];
+  const visitRule = (rule, path) => {
+    if (rule.rule !== "wait-for-connector")
+      return;
+    const context = asRecord2(rule.uipath)?.context;
+    const missing = missingContextKeys(context, true, bindings);
+    if (missing.length > 0) {
+      issues.push({
+        code: "STRICT_CONNECTOR_CONTEXT_INCOMPLETE",
+        path: `${path}.uipath.context`,
+        severity: "error",
+        message: `Connector rule "${String(rule.id ?? "?")}" is missing ` + `context entries: ${missing.join(", ")}. A rule carrying ` + "the connection but not the activity metadata deploys and " + "then has no event to wait for."
+      });
+    }
+    if (contextEntry(context, "metadata") === undefined)
+      return;
+    if (readActivityTypeId(context) === undefined) {
+      issues.push({
+        code: "STRICT_CONNECTOR_ACTIVITY_TYPE_ID",
+        path: `${path}.uipath.context[metadata].${ACTIVITY_TYPE_ID_PATH}`,
+        severity: "error",
+        message: activityTypeIdMessage(`rule "${typeof rule.id === "string" ? rule.id : "?"}"`, context, "The connection id alone does not identify the event to " + "wait for.")
+      });
+    }
+  };
+  const visitConditions = (conditions, path) => {
+    asArray(conditions).forEach((condition, conditionIndex) => {
+      const record = asRecord2(condition);
+      if (!record)
+        return;
+      asArray(record.rules).forEach((group, groupIndex) => {
+        asArray(group).forEach((rule, ruleIndex) => {
+          const ruleRecord = asRecord2(rule);
+          if (!ruleRecord)
+            return;
+          visitRule(ruleRecord, `${path}[${conditionIndex}].rules[${groupIndex}][${ruleIndex}]`);
+        });
+      });
+    });
+  };
+  for (const node of nodes) {
+    const id = typeof node.id === "string" ? node.id : "?";
+    const data = asRecord2(node.data);
+    visitConditions(data?.entryConditions, `nodes[${id}].data.entryConditions`);
+    visitConditions(data?.exitConditions, `nodes[${id}].data.exitConditions`);
+    for (const lane of asArray(data?.tasks)) {
+      for (const task of asArray(lane)) {
+        const taskRecord = asRecord2(task);
+        if (!taskRecord)
+          continue;
+        const taskId = typeof taskRecord.id === "string" ? taskRecord.id : "?";
+        visitConditions(taskRecord.entryConditions, `nodes[${id}].data.tasks[${taskId}].entryConditions`);
+      }
+    }
+  }
+  return issues;
+};
+var RECIPIENT_PREFIXES = [
+  "User:",
+  "UserGroup:",
+  "Role:",
+  "Email:",
+  "Expression:"
+];
+var recipientIssues = (recipient, path) => {
+  const value = recipient.Value;
+  if (typeof value !== "string")
+    return [];
+  const prefix = RECIPIENT_PREFIXES.find((candidate) => value.startsWith(candidate));
+  if (prefix !== undefined) {
+    return [
+      {
+        code: "STRICT_RECIPIENT_PREFIX_LEFT",
+        path: `${path}.Value`,
+        severity: "error",
+        message: `Recipient value "${value}" still carries the ` + `"${prefix}" marker. That marker picks the Type and is ` + "removed on the way in, so the assignment looks up a " + "name nobody has and the task ships assigned to no one."
+      }
+    ];
+  }
+  if (!value.startsWith("=vars.") || recipient.Type === 3)
+    return [];
+  return [
+    {
+      code: "STRICT_RECIPIENT_EXPRESSION_TYPE",
+      path: `${path}.Type`,
+      severity: "error",
+      message: `Recipient value "${value}" is an expression but carries ` + `Type ${String(recipient.Type)}. Type 0 sends it to a user ` + "lookup, Type 1 to a group lookup and Type 2 to an email " + "lookup, all on the literal text. An expression recipient " + "is Type 3."
+    }
+  ];
+};
+var checkActionRecipientShape = (nodes) => nodes.flatMap((node) => {
+  const nodeId = typeof node.id === "string" ? node.id : "?";
+  const lanes = asArray(asRecord2(node.data)?.tasks);
+  return lanes.flatMap((lane) => asArray(lane).flatMap((task) => {
+    const taskRecord = asRecord2(task);
+    const recipient = asRecord2(asRecord2(taskRecord?.data)?.recipient);
+    if (!taskRecord || !recipient)
+      return [];
+    const taskId = typeof taskRecord.id === "string" ? taskRecord.id : "?";
+    return recipientIssues(recipient, `nodes[${nodeId}].data.tasks[${taskId}].data.recipient`);
+  }));
+});
+var RESOURCE_TASK_TYPES = new Set([
+  "action",
+  "agent",
+  "api-workflow",
+  "case-management",
+  "execute-connector-activity",
+  "function",
+  "process",
+  "rpa",
+  "wait-for-connector"
+]);
+var collectBindingReferences = (value, path, found) => {
+  if (typeof value === "string") {
+    if (value.startsWith(BINDING_REFERENCE_PREFIX)) {
+      const id = value.slice(BINDING_REFERENCE_PREFIX.length);
+      if (id !== "" && !found.has(id))
+        found.set(id, path);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => {
+      collectBindingReferences(entry, `${path}[${index}]`, found);
+    });
+    return;
+  }
+  const record = asRecord2(value);
+  if (record === undefined)
+    return;
+  for (const [key, entry] of Object.entries(record)) {
+    collectBindingReferences(entry, `${path}.${key}`, found);
+  }
+};
+var isBindingReference = (value) => typeof value === "string" && value.startsWith(BINDING_REFERENCE_PREFIX);
+var checkTaskBindings = (nodes) => {
+  const issues = [];
+  for (const node of nodes) {
+    const stage = asRecord2(node.data);
+    const stageName = typeof stage?.label === "string" ? stage.label : "";
+    for (const lane of asArray(stage?.tasks)) {
+      for (const task of asArray(lane)) {
+        const taskRecord = asRecord2(task);
+        const type = taskRecord?.type;
+        const data = asRecord2(taskRecord?.data);
+        if (typeof type !== "string" || !NAME_BOUND_TASK_TYPES.has(type) || data === undefined) {
+          continue;
+        }
+        const identity = RESOLVED_IDENTITY_KEYS.filter((key) => data[key] !== undefined);
+        const unbound = ["name", "folderPath"].filter((field) => !isBindingReference(data[field]));
+        const taskName = typeof taskRecord?.displayName === "string" ? taskRecord.displayName : type;
+        if (identity.length === 0) {
+          const named = ["name", "folderPath"].filter((field) => typeof data[field] === "string" && data[field] !== "");
+          if (named.length > 0)
+            continue;
+          if (Object.keys(data).length === 0)
+            continue;
+          issues.push({
+            code: "STRICT_BINDINGS_TASK_ABSENT",
+            path: `nodes[${stageName}].data.tasks[${taskName}].data`,
+            severity: "error",
+            message: `Task "${taskName}" (${type}) names no resource ` + "at all: no `name`, no `folderPath`, and no " + "resolved id. This plan binds its other " + "resources, so this one was missed rather than " + "left for later — and nothing reports it " + "otherwise, because the plan-wide bindings check " + "only fires on an empty array and the literal " + "check only fires on a literal. The task cannot " + "run: give it a name/folderPath binding pair."
+          });
+          continue;
+        }
+        if (unbound.length === 0)
+          continue;
+        issues.push({
+          code: "STRICT_BINDINGS_TASK_UNBOUND",
+          path: `nodes[${stageName}].data.tasks[${taskName}].data`,
+          severity: "error",
+          message: `Task "${taskName}" (${type}) pins its resource with ` + `${identity.join(", ")}, but ${unbound.join(" and ")} ` + `${unbound.length === 1 ? `is not a ${BINDING_REFERENCE_PREFIX} reference` : `are not ${BINDING_REFERENCE_PREFIX} references`}. A resolved ` + "resource task binds both: `name` and `folderPath` " + "each point at a root bindings entry, and " + "bindings_v2.json is derived from those. A raw id " + "binds nothing, so the solution ships resolving this " + "task to nothing, and the id itself does not survive " + "a move to another tenant. Bind the pair and drop the " + "raw id."
+        });
+      }
+    }
+  }
+  return issues;
+};
+var resourceTaskCount = (nodes) => {
+  let count = 0;
+  for (const node of nodes) {
+    for (const lane of asArray(asRecord2(node.data)?.tasks)) {
+      for (const task of asArray(lane)) {
+        const taskRecord = asRecord2(task);
+        const type = taskRecord?.type;
+        if (typeof type === "string" && RESOURCE_TASK_TYPES.has(type) && Object.keys(asRecord2(taskRecord?.data) ?? {}).length > 0) {
+          count += 1;
+        }
+      }
+    }
+  }
+  return count;
+};
+var checkResourceBindings = (parsed, nodes) => {
+  const issues = [];
+  const bindings = asArray(parsed.bindings).map((entry) => asRecord2(entry)).filter((entry) => entry !== undefined);
+  const bindingIds = new Set(bindings.map((entry) => entry.id).filter((id) => typeof id === "string"));
+  const seenIds = new Set;
+  const reportedIds = new Set;
+  for (const entry of bindings) {
+    const id = entry.id;
+    if (typeof id !== "string" || id === "")
+      continue;
+    if (!seenIds.has(id)) {
+      seenIds.add(id);
+      continue;
+    }
+    if (reportedIds.has(id))
+      continue;
+    reportedIds.add(id);
+    issues.push({
+      code: "STRICT_BINDINGS_ID_DUPLICATE",
+      path: `bindings[${id}]`,
+      severity: "error",
+      message: `Two or more bindings share the id "${id}". A ` + `${BINDING_REFERENCE_PREFIX}${id} reference resolves to ` + "whichever entry a consumer scans first, so the one that " + "wins depends on array order — and the losing entry still " + "reads as though it applies. Give each entry its own id."
+    });
+  }
+  const references = new Map;
+  collectBindingReferences(parsed.nodes, "nodes", references);
+  collectBindingReferences(parsed.metadata, "metadata", references);
+  for (const [id, path] of references) {
+    if (bindingIds.has(id))
+      continue;
+    issues.push({
+      code: "STRICT_BINDINGS_REFERENCE_UNRESOLVED",
+      path,
+      severity: "error",
+      message: `"${BINDING_REFERENCE_PREFIX}${id}" points at no entry in the ` + "root bindings array, so nothing resolves it at run time. Add " + `a binding with id "${id}", or correct the reference.`
+    });
+  }
+  const everywhere = new Map;
+  for (const [key, value] of Object.entries(parsed)) {
+    if (key === "bindings")
+      continue;
+    collectBindingReferences(value, key, everywhere);
+  }
+  const referenced = new Set(everywhere.keys());
+  const unreferenced = new Set;
+  for (const entry of bindings) {
+    const id = entry.id;
+    if (typeof id !== "string" || id === "")
+      continue;
+    if (referenced.has(id) || unreferenced.has(id))
+      continue;
+    unreferenced.add(id);
+    const described = [entry.resource, entry.propertyAttribute].filter((part) => typeof part === "string" && part !== "").join(" ");
+    issues.push({
+      code: "STRICT_BINDINGS_UNREFERENCED",
+      path: `bindings[${id}]`,
+      severity: "warning",
+      message: `No node references the binding "${id}"` + (described === "" ? " (an entry with no `resource` or `propertyAttribute`, so it names no resource at all)" : ` (${described})`) + ", so it binds a resource nothing uses, and bindings_v2.json " + "carries it into the solution. Delete the entry and run " + "`uip maestro case bindings sync <caseplan.json>`, or " + `reference it as ${BINDING_REFERENCE_PREFIX}${id} from the ` + "task that needs it."
+    });
+  }
+  const resourceTasks = resourceTaskCount(nodes);
+  if (bindings.length > 0) {
+    issues.push(...checkTaskBindings(nodes));
+  } else if (resourceTasks > 0) {
+    issues.push({
+      code: "STRICT_BINDINGS_ABSENT",
+      path: "bindings",
+      severity: "warning",
+      message: `The root bindings array is empty, but ${resourceTasks} task(s) ` + "name a platform resource (process, agent, rpa, action, " + "api-workflow, function, child case or connector). Every such " + "task needs a name/folderPath binding pair — or, for a " + "connector, a connection and folder key — and bindings_v2.json " + "is derived from that array, so an empty one publishes a " + "solution that resolves none of them."
+    });
+  }
+  return issues;
+};
+var runStrictCaseRules = (parsed) => {
+  const nodes = Array.isArray(parsed.nodes) ? parsed.nodes : [];
+  const variables = asRecord2(parsed.variables);
+  const triggerIds = new Set(nodes.flatMap((node) => (nodeType(node) === "uipath.case.trigger" || nodeType(node) === "case-management:Trigger") && typeof node.id === "string" ? [node.id] : []));
+  return [
+    ...checkStagesHaveTasks(nodes),
+    ...checkJsExpressionsParse(parsed),
+    ...checkJsExpressionScope(parsed),
+    ...checkVariableContract(variables, triggerIds),
+    ...checkInputOutputCompanions(variables, nodes),
+    ...checkConnectorRuleContext(nodes, parsed.bindings),
+    ...checkActionRecipientShape(nodes),
+    ...checkResourceBindings(parsed, nodes),
+    ...checkConnectionBindings(parsed)
+  ];
+};
+export {
+  runStrictCaseRules
+};
+
+//# debugId=8B995151F8DE8CA864756E2164756E21