@uipath/skills 1.199.0 → 1.200.0

package/skills/uipath-maestro-bpmn/validator/README.md

@@ -1,224 +0,0 @@
-# Maestro BPMN Validator (bundled, offline)
-
-A dependency-light, offline semantic validator for UiPath Maestro BPMN XML. It
-parses the BPMN with `bpmn-moddle` using the UiPath extension descriptor (the
-same `getModdle()` + `fromXML()` pattern as PO.Frontend), reconstructs the
-PO.Frontend `Node[] / Edge[] / CanvasState` model from the parse tree, and runs
-**all 19** PO.Frontend validation rules plus the variable-validation checks
-(`VARIABLE_DOES_NOT_EXIST`, including element-local `result.X`, and the
-flow-order `VARIABLE_NOT_SET` warning) and an optional connection-liveness ping.
-
-> **Authoring scope:** everything under `test/fixtures/` is validator test data,
-> not authoring material. **Do not read the fixtures to infer the BPMN pattern**
-> — it is the top reason authoring runs out of time. Author from the complete
-> minimal file in
-> [../references/structural-bpmn.md](../references/structural-bpmn.md#a-complete-minimal-file-author-from-this-not-from-fixtures)
-> instead. This README documents the validator and its test suite; run the
-> validator (below) as your check, and leave the corpus to CI.
-
-## Usage
-
-```bash
-npm install
-node validate-bpmn.mjs <bpmn-file> [resources]
-```
-
-- Prints `VALID` and exits `0` when there are no ERROR-severity findings.
-- Otherwise lists every finding (rule code + message) and exits `1`.
-- WARNING-severity findings are printed but do not gate.
-- A strict XML well-formedness gate (sax strict mode) runs **before** the
-  `bpmn-moddle` parse and exits `2` on malformed input — unescaped `&`/`<`, `--`
-  inside a comment, mismatched tags. `bpmn-moddle`'s SAX parser is lenient and
-  would accept these, but the Studio Web canvas import rejects them, so the
-  validator must too: a safety net that is more permissive than the real import
-  gives false confidence.
-- `resources` (optional): a numeric folder id (or comma-separated release names)
-  for the connection-liveness ping via the `uip` CLI. Best-effort; a missing or
-  unauthenticated CLI is reported as a NOTE, never a hard failure.
-
-```bash
-npm test   # runs all three suites below; green = no drift from the frontend
-```
-
-## Test suites (`test/`)
-
-`npm test` runs the layers below and asserts all 29 rule codes are exercised
-(plus a CLI well-formedness-gate check):
-
-1. **Crafted-invalid XML coverage** (`run-tests.mjs`): for each rule, a minimal
-   BPMN that should trip exactly that rule's code, plus a check that valid twins
-   don't. Proves the full parse → model → rules pipeline end-to-end.
-2. **Ported PO.Frontend rule tests** (`test/ported-rule-tests.mjs`): a 1:1
-   translation of every `PO.Frontend/src/services/validation/bpmn/rules/*.test.ts`
-   case plus the variable-validation cases from `VariableUtil.test.ts`
-   (173 assertions). Each case carries a `// FE:` comment naming the
-   originating frontend test and runs the same synthetic Node/Edge/CanvasState
-   graph through **our** rule engine. This is the primary drift detector: if our
-   port disagrees with a frontend test's expectation, this suite fails.
-3. **Integration over real `.bpmn` files** (`test/integration.test.mjs`): every
-   file in `test/fixtures/` is a real, externally-validated artifact (backend
-   BpmnParser/Worker/Athena/V2-E2E TestData, and PO.Frontend editor mocks),
-   bundled so the suite is self-contained in CI. These files exist to exercise
-   the rule engine — they are **not** authoring templates; see the authoring-scope
-   note at the top before reaching for one as an example. `fixtures/known-good/`
-   must produce **zero** ERROR-severity findings; `fixtures/expected-findings/` assert
-   the exact ERROR codes the frontend would also raise (each verified by reading
-   the file). Set `MAESTRO_BPMN_TESTDATA` / `MAESTRO_BPMN_FRONTEND_MOCKS` to also
-   sweep a live corpus during development.
-
-## Parity status
-
-**Full parity with the PO.Frontend rule engine is now reached for every rule
-except two clearly-bounded residuals (below).** Each rule is a faithful port of
-the frontend rule of the same name: same inputs → same outputs, verified by the
-1:1 ported test suite (frontend test inputs) and the real-`.bpmn` integration
-corpus (zero ERROR findings on 31 known-good files; exact ERROR-code match on 28
-expected-findings files).
-
-### Closed gaps (now at parity)
-
-1. **`RequiredFields` flags ABSENT required fields, not only present-but-empty.**
-   Frontend `RequiredFieldsRule.ts:24-27` + `ValidateRequiredFieldsInData.ts:15-16`
-   fire on `field.required && isNilOrEmpty(field.value)`. On canvas every field a
-   serviceType declares is present in node data, so an *unbound* required field is
-   present-with-empty-value. In exported BPMN that field is simply absent. The
-   model (`model.mjs`) attaches the serviceType's full registry required-field name
-   set (`bpmn-spec.json`, 128 `required` entries) as `uipath.requiredFieldNames`,
-   and the rule now treats an absent required name exactly as the frontend treats
-   an unbound field. Present-but-empty still fires too, in the frontend's
-   context → inputs → outputs order, one finding per node.
-2. **`VARIABLE_NOT_SET` (WARNING) is now implemented.** Port of the flow-order
-   reachability half of `VariableUtil.validateVariablesInExpression`
-   (`VariableUtil.ts:758-866`), built on the pure topology helpers
-   `getSourceEdgeMappings` (`:121-130`), `mapNodeOutputsToVariables` (`:539-579`),
-   `getVariablesForSubProcess` (`:495-525`), `getAvailableVariablesFromSourceNodes`
-   (`:303-389`, backward BFS over sequence-flow edges + boundary re-parenting +
-   subprocess scope), and `getAvailableVariablesForElement` (`:401-481`, parent
-   chain + event-subprocess shared scope + subprocess EndEvent exposure). A
-   *declared* variable referenced where no flow path reaches its producer fires
-   `VARIABLE_NOT_SET` (WARNING, non-gating). **Skipped entirely for Case
-   Management** (`VariableUtil.ts:826-828`). Root variables are globally available
-   and never warn.
-3. **`result.X` existence is now validated element-locally.** Frontend puts an
-   unresolved `result.X` in the non-existing set (`VariableUtil.ts:263`) and a
-   `result.X` is valid only if `X` names one of the *referencing element's own*
-   outputs (`isResultVariableValidForElement`, `:166-178`). The port previously
-   skipped all `result.` refs unconditionally; it now resolves `result.X` against
-   the element's own output identifiers and fires `VARIABLE_DOES_NOT_EXIST` for an
-   invalid one (edge conditions have no own outputs, so every `result.X` on an
-   edge is invalid, matching the frontend).
-4. **`ConnectionRule` unknown-type fallback now returns `false`.** Frontend
-   `canNodeTypesBeConnected` (`BPMNTypesUtils.ts:51-82`) returns **false** when no
-   rule matches the source type, yielding `INVALID_CONNECTION_TYPE` (WARNING). The
-   port previously returned `true` for unknown source types; it now matches the
-   frontend. The abstract-type inheritance the frontend additionally walks is
-   already folded into our concrete allow-map (every concrete activity/event type
-   has an explicit entry), so an unknown source type genuinely has no rule. The
-   ported `ConnectionRule` test was un-doctored to the frontend's actual input
-   (source `"output"` → target `"input"`, both unknown) per `ConnectionRule.test.ts:33-43`.
-5. **Custom-output accessor gating aligned to the frontend.** Both the existence
-   check and `VARIABLE_NOT_SET` now collect a custom output's `source` only when
-   `getAccessorFromType(type) === "source"`, and `body` only when the accessor is
-   `body` (`VariableUtil.ts:952-968`).
-
-### Earlier fixes (already at parity before this round)
-
-6. **Empty `<conditionExpression/>` crash — FIXED.** An empty condition element
-   parses to a moddle object with no `.body`; the model now treats it as "no
-   condition" (frontend behavior) instead of crashing the string-based rules.
-7. **`FakeJoinRule` over-firing — FIXED (match frontend behavior).** See the
-   residual note below.
-8. **`validateRequiredFields(null)` crash — FIXED.** Matches the frontend's
-   `if (!nodes || !edges) return []` guard.
-9. **`VARIABLE_DOES_NOT_EXIST` false positives on node-output variables — FIXED.**
-   A node's `<uipath:output var="x">` declares variable `x`
-   (`mapNodeOutputsToVariables`: `id: v.var`); these are now in the known-id set,
-   and script-task IO under `uipath:Mapping` is recognized.
-
-## Genuine residuals (the only two)
-
-These are the **only** places this port is not byte-for-byte identical to the
-frontend, and both are bounded and justified — not drift.
-
-- **Dynamic IS-connector required-ness needs `registry get` enrichment (shared
-  with the frontend).** For Integration-Service connector activity types whose
-  required fields are NOT in the static `bpmn-spec.json` registry — their
-  required-ness only materializes after a live `registry get` enrichment — the
-  model has no `requiredFieldNames`, so `RequiredFields` stays conservative
-  (only present-but-empty fires; absence cannot be judged). **The frontend has
-  the identical limitation:** it also needs that enrichment to learn the field is
-  required. For every serviceType present in the static registry, absent-required
-  detection is at full parity.
-- **`FAKE_JOIN` is dormant on real/exported BPMN (faithful to the frontend).**
-  The frontend `FakeJoinRule` matches only the **literal** abstract types
-  `"bpmn:Activity"` / `"bpmn:Event"`, but the canvas assigns every node its
-  **concrete** `$type` (`bpmn:Task`, `bpmn:EndEvent`, …; `bpmn-from-xml.ts` sets
-  `type: $type`). The rule therefore never fires on exported BPMN — its own
-  source carries a `TODO` admitting it must be rewritten to walk the inherited-
-  type chain, which it does not yet do. The port applies the frontend's exact
-  predicate, so it is faithful (same inputs → same outputs); its logic is proven
-  in the ported suite (which feeds literal abstract types, like the frontend
-  test) and is intentionally not triggerable via real XML.
-
-## Architecture (Phase 1 → Phase 2)
-
-| File | Role |
-| --- | --- |
-| `rules.mjs` | **Self-contained rule engine** — the swap target. In Phase 2 this single module is replaced by the published npm package with no behavior change. |
-| `model.mjs` | Integration glue: reconstructs the frontend model from the moddle tree; bundles registry metadata. |
-| `validate-bpmn.mjs` | CLI entry: parse → build model → run rules → gate. |
-| `bpmn-spec.json` | Bundled maestro-sdk registry, consumed offline for RequiredFields. |
-| `uipath-moddle.v1.json` | Verbatim UiPath moddle descriptor from PO.Frontend. |
-
-## Rule coverage
-
-Each rule is a faithful port of the PO.Frontend rule of the same name. Source
-column shows where the rule's truth comes from offline.
-
-| # | Rule (PO.Frontend) | Source | Codes emitted |
-| --- | --- | --- | --- |
-| 1 | ConditionalFlow | XML graph | `MISSING_CONDITION_EXPRESSION` |
-| 2 | Connection | XML graph | `INVALID_CONNECTION`, `INVALID_CONNECTION_TYPE` |
-| 3 | DuplicateErrorEventSubprocess | XML graph + `bpmn:Error` objects | `MULTIPLE_CATCH_ALL_ERROR_EVENT_SUBPROCESS`, `DUPLICATE_ERROR_EVENT_SUBPROCESS` |
-| 4 | EmptyStartEventDefinitionInSubProcess | XML graph | `START_EVENT_WITH_DEFINITION_IN_SUBPROCESS`, `START_EVENT_WITHOUT_DEFINITION_IN_EVENT_SUBPROCESS`, `INVALID_EVENT_DEFINITION_IN_EVENT_SUBPROCESS` |
-| 5 | ErrorBoundaryEvent | XML graph + `bpmn:Error` objects | `ERROR_BOUNDARY_EVENT_EMPTY_ERROR_REF`, `ERROR_BOUNDARY_EVENT_REQUIRES_ERROR_CODE`, `MULTIPLE_CATCH_ALL_BOUNDARY_EVENTS_ON_TASK`, `DUPLICATE_ERROR_BOUNDARY_EVENT_ON_TASK` |
-| 6 | ErrorEndEvent | XML graph | `ERROR_END_EVENT_MISSING_EXCEPTION` |
-| 7 | FakeJoin | XML graph | `FAKE_JOIN` |
-| 8 | MessageFlowObjectsPool | XML graph (pools) | `SAME_POOL_MESSAGE_FLOW` |
-| 9 | MissingResource | XML extension (`serviceType` + bindings) | `MISSING_RESOURCE` (WARNING) |
-| 10 | MissingRootVariable | XML extension (variables + outputs) | `MISSING_ROOT_VARIABLE` (WARNING) |
-| 11 | NoAssignments | Pure check on expressions | `ASSIGNMENT_NOT_ALLOWED` (WARNING) |
-| 12 | RequiredFields | **Registry metadata** (`bpmn-spec.json`) | `EMPTY_REQUIRED_FIELD` |
-| 13 | SequenceFlowPoolCrossing | XML graph (pools) | `CROSSING_POOL_BOUNDARY` |
-| 14 | SequenceFlowSubProcessCrossing | XML graph | `CROSSING_SUBPROCESS_BOUNDARY` |
-| 15 | SingleBlankStartEvent | XML graph | `MULTIPLE_BLANK_START_EVENTS` |
-| 16 | SingleStartEventInEventSubProcess | XML graph | `MULTIPLE_START_EVENTS_IN_EVENT_SUBPROCESS` |
-| 17 | SuperfluousGateway | XML graph | `SUPERFLUOUS_GATEWAY` |
-| 18 | TaskTimer | Pure check (range) | `TASK_TIMER_OUT_OF_RANGE` (WARNING) |
-| 19 | TimerDuration | Pure check (ISO 8601) | `TIMER_DURATION_INVALID`, `TIMER_DURATION_WEEK_UNSUPPORTED` (WARNING) |
-| + | Variable existence (incl. element-local `result.X`) | XML extension + declared variables | `VARIABLE_DOES_NOT_EXIST` |
-| + | Variable-not-set (flow-order reachability) | XML topology + declared variables | `VARIABLE_NOT_SET` (WARNING) |
-
-## RequiredFields parity note
-
-The PO.Frontend `RequiredFields` rule fires when `field.required && isNilOrEmpty(field.value)`
-(`ValidateRequiredFieldsInData.ts:15-16`). On the canvas every field a serviceType
-declares is present in node data with its `required` flag, so an *unbound*
-required field is present-with-empty-value and is flagged.
-
-Offline, `field.required` is recovered from the bundled registry
-(`bpmn-spec.json`, 128 `required` entries keyed by serviceType; names are the
-serialized names) and the model attaches the full required-name set as
-`uipath.requiredFieldNames`. The rule fires for a required field that is either
-**present-but-empty** OR entirely **absent** from the serialized data (an absent
-required field is the exported-BPMN form of the canvas's unbound field), in the
-frontend's context → inputs → outputs order, one finding per node. This reaches
-full parity for every serviceType present in the static registry.
-
-The single bounded exception is dynamic Integration-Service connector activity
-types whose required-ness is **not** in the static registry (it only
-materializes after a live `registry get` enrichment): for those,
-`requiredFieldNames` is undefined and absence cannot be judged, so the rule stays
-conservative (only present-but-empty fires). The frontend shares this exact
-limitation — it also needs the enrichment to know the field is required. See
-"Genuine residuals" above.

package/skills/uipath-maestro-bpmn/validator/model.mjs

@@ -1,419 +0,0 @@
-// Reconstruct the PO.Frontend Node[]/Edge[]/CanvasState model from a parsed
-// bpmn-moddle tree. This is the integration layer (Phase 1). It mirrors
-// PO.Frontend/src/services/serialization/bpmn-from-xml.ts closely enough that
-// the ported rule engine in rules.mjs sees the same fields it sees on canvas.
-//
-// PHASE 2 NOTE: this file and validate-bpmn.mjs are the only integration glue.
-// rules.mjs (the rule logic) is the swap target for the future npm package.
-
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-// ---------------------------------------------------------------------------
-// Registry: required-field metadata (bpmn-spec.json). Bundled so RequiredFields
-// runs fully offline. Maps serviceType -> Set<requiredFieldName>.
-// ---------------------------------------------------------------------------
-let _requiredFieldIndex;
-function loadRequiredFieldIndex() {
-  if (_requiredFieldIndex) return _requiredFieldIndex;
-  const index = new Map();
-  try {
-    const spec = JSON.parse(readFileSync(join(__dirname, "bpmn-spec.json"), "utf8"));
-    for (const [serviceType, def] of Object.entries(spec.extensionTypes ?? {})) {
-      const names = new Set();
-      for (const f of def.contextFields ?? []) {
-        // Only fields the user can actually populate. Hidden fields with a
-        // default are auto-filled by the designer and never empty in practice,
-        // so requiring them offline would false-positive; skip hidden+defaulted.
-        if (f.required && !(f.hidden && f.defaultValue !== null && f.defaultValue !== undefined)) {
-          names.add(f.name);
-        }
-      }
-      for (const f of def.inputFields ?? []) {
-        if (f.required) names.add(f.name);
-      }
-      if (names.size) index.set(serviceType, names);
-    }
-  } catch {
-    // Registry not bundled: RequiredFields degrades to a no-op (documented).
-  }
-  _requiredFieldIndex = index;
-  return index;
-}
-
-// ---------------------------------------------------------------------------
-// moddle helpers
-// ---------------------------------------------------------------------------
-const ext = (el) => el?.extensionElements?.values ?? [];
-const findExt = (el, type) => ext(el).find((e) => e.$type === type);
-
-function eventDefinitionOf(el) {
-  const defs = el?.eventDefinitions;
-  if (!defs || !defs.length) return undefined;
-  const d = defs[0];
-  const out = { type: d.$type, id: d.id };
-  if (d.errorRef) out.errorRef = d.errorRef.id ?? d.errorRef;
-  if (d.messageRef) out.messageRef = d.messageRef.id ?? d.messageRef;
-  if (d.signalRef) out.signalRef = d.signalRef.id ?? d.signalRef;
-  if (d.escalationRef) out.escalationRef = d.escalationRef.id ?? d.escalationRef;
-  if (d.$type === "bpmn:TimerEventDefinition") {
-    if (d.timeDuration) {
-      out.timerType = "timeDuration";
-      out.timeDuration = d.timeDuration.body ?? d.timeDuration;
-    } else if (d.timeCycle) {
-      out.timerType = "timeCycle";
-      out.timeCycle = d.timeCycle.body ?? d.timeCycle;
-    } else if (d.timeDate) {
-      out.timerType = "timeDate";
-      out.timeDate = d.timeDate.body ?? d.timeDate;
-    }
-  }
-  return out;
-}
-
-// Map a uipath:Activity / uipath:Event extension element into the frontend
-// `node.data.uipath` shape consumed by the rules.
-function mapUiPathActivity(actEl) {
-  const uipath = {};
-  uipath.serviceType = actEl.type?.value ?? actEl.type ?? undefined;
-  uipath.version = actEl.type?.version ?? actEl.version ?? "v1";
-
-  const mapInput = (i) => ({ name: i.name, type: i.type, subType: i.subType, value: i.value, target: i.target, body: i.body });
-  const mapOutput = (o) => ({
-    name: o.name,
-    type: o.type,
-    subType: o.subType,
-    source: o.source,
-    var: o.var,
-    body: o.body,
-    custom: o.custom === "true" || o.custom === true,
-    target: o.target,
-  });
-
-  uipath.context = (actEl.context?.input ?? []).map(mapInput);
-  uipath.inputs = (actEl.input ?? []).map(mapInput);
-  uipath.outputs = (actEl.output ?? []).map(mapOutput);
-  return uipath;
-}
-
-function mapErrorMapping(emEl) {
-  return (emEl?.error ?? []).map((e) => ({
-    id: e.id,
-    errorRef: e.errorRef,
-    priority: e.priority,
-    condition: e.condition,
-    detail: e.detail,
-    retryable: e.retryable === "true" || e.retryable === true,
-  }));
-}
-
-function mapVariables(varsEl) {
-  if (!varsEl) return undefined;
-  const map = (v) => ({
-    id: v.id,
-    name: v.name,
-    type: v.type,
-    subType: v.subType,
-    canonicalId: v.canonicalId,
-    elementId: v.elementId,
-    default: v.default,
-  });
-  return {
-    inputs: (varsEl.input ?? []).map(map),
-    inputOutputs: (varsEl.inputOutput ?? []).map(map),
-    outputs: (varsEl.output ?? []).map(map),
-  };
-}
-
-// Populate node.data.uipath from a flow element's extensionElements.
-// `requiredFieldIndex` supplies, per serviceType, the registry's required field
-// names; matching serialized fields get `required: true` so RequiredFields can
-// run offline with the same `field.required && isNilOrEmpty(value)` semantics
-// the canvas uses.
-function buildNodeUiPath(el, requiredFieldIndex) {
-  // Script tasks / BPMN.Variables nodes carry their IO under uipath:Mapping,
-  // which has the same { type, context, input, output } shape as
-  // uipath:Activity / uipath:Event. Treat all three uniformly so node-output
-  // variables (e.g. a script writing `var="x"`) are recovered.
-  const act = findExt(el, "uipath:Activity") ?? findExt(el, "uipath:Event") ?? findExt(el, "uipath:Mapping");
-  const em = findExt(el, "uipath:ErrorMapping");
-  const vars = findExt(el, "uipath:Variables");
-  let uipath;
-  if (act) uipath = mapUiPathActivity(act);
-  if (em) {
-    uipath = uipath ?? {};
-    uipath.errorMapping = mapErrorMapping(em);
-  }
-  if (vars) {
-    uipath = uipath ?? {};
-    uipath.variables = mapVariables(vars);
-  }
-  // Mark required fields from the registry onto serialized fields by name match,
-  // and attach the full required-name set so RequiredFieldsRule can also detect
-  // required fields that are entirely ABSENT from the serialized data (frontend
-  // RequiredFieldsRule iterates every field in the node's data and fires on
-  // `field.required && isNilOrEmpty(field.value)` — an unbound required field is
-  // present-with-empty-value on canvas, which corresponds to absent-in-XML here).
-  const st = uipath?.serviceType;
-  const requiredNames = st ? requiredFieldIndex.get(st) : undefined;
-  if (requiredNames) {
-    for (const group of [uipath.context, uipath.inputs, uipath.outputs]) {
-      if (!Array.isArray(group)) continue;
-      for (const f of group) if (requiredNames.has(f.name)) f.required = true;
-    }
-    uipath.requiredFieldNames = [...requiredNames];
-  }
-  return uipath;
-}
-
-const ABSTRACT_ACTIVITY = new Set([
-  "bpmn:Task",
-  "bpmn:ServiceTask",
-  "bpmn:UserTask",
-  "bpmn:ScriptTask",
-  "bpmn:SendTask",
-  "bpmn:ReceiveTask",
-  "bpmn:BusinessRuleTask",
-  "bpmn:ManualTask",
-  "bpmn:CallActivity",
-  "bpmn:SubProcess",
-  "bpmn:AdHocSubProcess",
-  "bpmn:Transaction",
-]);
-const ABSTRACT_EVENT = new Set([
-  "bpmn:StartEvent",
-  "bpmn:EndEvent",
-  "bpmn:IntermediateCatchEvent",
-  "bpmn:IntermediateThrowEvent",
-  "bpmn:BoundaryEvent",
-]);
-function abstractTypeOf(type) {
-  if (ABSTRACT_ACTIVITY.has(type)) return "bpmn:Activity";
-  if (ABSTRACT_EVENT.has(type)) return "bpmn:Event";
-  return undefined;
-}
-
-// ---------------------------------------------------------------------------
-// Build a flat Node for one flow element. `parentId`/`parentElement` describe
-// the containing Process or SubProcess.
-// ---------------------------------------------------------------------------
-function buildNode(el, parent, requiredFieldIndex) {
-  const data = {};
-  data.label = el.name ?? undefined;
-
-  const ed = eventDefinitionOf(el);
-  if (ed) data.eventDefinition = ed;
-
-  if (el.$type === "bpmn:SubProcess") data.triggeredByEvent = el.triggeredByEvent === true;
-  if (el.$type === "bpmn:BoundaryEvent" && el.attachedToRef) data.attachedToId = el.attachedToRef.id ?? el.attachedToRef;
-
-  const uipath = buildNodeUiPath(el, requiredFieldIndex);
-  if (uipath) data.uipath = uipath;
-
-  if (parent) data.parentElement = { id: parent.id, type: parent.$type };
-
-  return {
-    id: el.id,
-    type: el.$type,
-    parentId: parent && parent.$type === "bpmn:SubProcess" ? parent.id : undefined,
-    abstractType: abstractTypeOf(el.$type),
-    data,
-  };
-}
-
-function buildEdge(el, parent) {
-  const data = {};
-  if (el.name) data.label = el.name;
-  if (el.conditionExpression) {
-    // A FormalExpression moddle element carries its text in `.body`; an empty
-    // `<conditionExpression/>` element has no `.body` (undefined). Only a real
-    // string body is a condition — never fall back to the moddle object itself,
-    // which would crash the string-based rules (matches frontend: an empty
-    // conditionExpression element means "no condition expression").
-    let body = el.conditionExpression.body ?? el.conditionExpression;
-    if (typeof body === "string") {
-      if (body && !body.startsWith("=")) body = `=${body}`;
-      data.conditionExpression = body;
-    }
-  }
-  // defaultFlow: source gateway's @default points to this flow.
-  const source = el.sourceRef;
-  if (source?.default && (source.default.id ?? source.default) === el.id) data.defaultFlow = true;
-  if (parent) data.parentElement = { id: parent.id, type: parent.$type };
-  return {
-    id: el.id,
-    type: el.$type,
-    source: el.sourceRef?.id ?? el.sourceRef,
-    target: el.targetRef?.id ?? el.targetRef,
-    data,
-  };
-}
-
-const FLOW_EDGE_TYPES = new Set(["bpmn:SequenceFlow", "bpmn:MessageFlow", "bpmn:Association"]);
-
-// Recursively collect nodes & edges for one container (Process or SubProcess).
-// `rootParentId` is the parentId assigned to the container's direct flow nodes:
-//   undefined for a stand-alone process (frontend root scope), or the pool id
-//   when the process is contained in a collaboration participant. Sub-process
-//   children carry parentId = sub-process id (frontend behavior).
-function collectContainer(container, requiredFieldIndex, nodesOut, edgesOut, rootParentId) {
-  const flowElements = container.flowElements ?? [];
-  for (const el of flowElements) {
-    if (FLOW_EDGE_TYPES.has(el.$type)) {
-      edgesOut.push(buildEdge(el, container));
-      continue;
-    }
-    const node = buildNode(el, container, requiredFieldIndex);
-    // Override parentId for direct children of a Process container.
-    if (container.$type === "bpmn:Process") node.parentId = rootParentId;
-    nodesOut.push(node);
-    if (el.$type === "bpmn:SubProcess") {
-      collectContainer(el, requiredFieldIndex, nodesOut, edgesOut, rootParentId);
-    }
-  }
-}
-
-function buildRootUiPath(processEl) {
-  const vars = findExt(processEl, "uipath:Variables");
-  if (!vars) return undefined;
-  return { variables: mapVariables(vars) };
-}
-
-// ---------------------------------------------------------------------------
-// Public: build the full model (CanvasState-like) from a moddle definitions.
-// ---------------------------------------------------------------------------
-export function buildModel(definitions) {
-  const requiredFieldIndex = loadRequiredFieldIndex();
-  const rootElements = definitions.rootElements ?? [];
-
-  // Global event objects (Errors/Messages/Signals/Escalations).
-  const objects = { errors: [], messages: [], signals: [], escalations: [] };
-  for (const el of rootElements) {
-    if (el.$type === "bpmn:Error") objects.errors.push({ id: el.id, name: el.name, errorCode: el.errorCode });
-    else if (el.$type === "bpmn:Message") objects.messages.push({ id: el.id, name: el.name });
-    else if (el.$type === "bpmn:Signal") objects.signals.push({ id: el.id, name: el.name });
-    else if (el.$type === "bpmn:Escalation") objects.escalations.push({ id: el.id, name: el.name, escalationCode: el.escalationCode });
-  }
-
-  const collaboration = rootElements.find((e) => e.$type === "bpmn:Collaboration");
-  const processes = rootElements.filter((e) => e.$type === "bpmn:Process");
-  const processById = new Map(processes.map((p) => [p.id, p]));
-
-  const diagramsById = {};
-  let rootDiagramId;
-  let rootNode;
-
-  const procContainerNode = (proc, parentId) => ({
-    id: proc.id,
-    type: "bpmn:Process",
-    parentId,
-    abstractType: undefined,
-    data: { label: proc.name, uipath: buildRootUiPath(proc) },
-  });
-
-  if (collaboration) {
-    // Single collaboration diagram: pools + every participant's process flow
-    // nodes, with collaboration-level message flows. Pool lookup (walk parentId
-    // up to bpmn:Participant) resolves because each process's flow nodes get
-    // parentId = pool id, and the Process container node sits under the pool.
-    const nodes = [];
-    const edges = [];
-    for (const p of collaboration.participants ?? []) {
-      nodes.push({
-        id: p.id,
-        type: "bpmn:Participant",
-        parentId: undefined,
-        abstractType: undefined,
-        data: { label: p.name, processRef: p.processRef?.id ?? p.processRef },
-      });
-      const proc = processById.get(p.processRef?.id ?? p.processRef);
-      if (proc) {
-        nodes.push(procContainerNode(proc, p.id));
-        collectContainer(proc, requiredFieldIndex, nodes, edges, p.id);
-        if (!rootNode) rootNode = procContainerNode(proc, undefined);
-      }
-    }
-    for (const mf of collaboration.messageFlows ?? []) {
-      edges.push(buildEdge(mf, collaboration));
-    }
-    rootDiagramId = collaboration.id;
-    diagramsById[collaboration.id] = {
-      diagramId: collaboration.id,
-      root: { id: collaboration.id, type: collaboration.$type },
-      nodes,
-      edges,
-    };
-  } else {
-    // Stand-alone process(es): one diagram each, root-scope flow nodes at
-    // parentId undefined (frontend root scope). The Process container node is
-    // included so container-scoped rules (SingleBlankStartEvent) can see it.
-    for (const proc of processes) {
-      const nodes = [procContainerNode(proc, undefined)];
-      const edges = [];
-      collectContainer(proc, requiredFieldIndex, nodes, edges, undefined);
-      const diagramId = proc.id;
-      diagramsById[diagramId] = {
-        diagramId,
-        root: { id: proc.id, type: proc.$type },
-        nodes,
-        edges,
-      };
-      if (!rootDiagramId) {
-        rootDiagramId = diagramId;
-        rootNode = procContainerNode(proc, undefined);
-      }
-    }
-  }
-
-  return {
-    rootDiagramId,
-    root: rootNode ?? { id: "root", type: "bpmn:Process", data: {} },
-    diagramsById,
-    objects,
-  };
-}
-
-// Build the set of known variable identifiers for variable-existence checks:
-// ids AND names AND canonicalIds, across root + every node scope.
-export function collectKnownVariableIds(canvasState) {
-  const ids = new Set();
-  const add = (v) => {
-    if (v?.id) ids.add(v.id);
-    if (v?.name) ids.add(v.name);
-    if (v?.canonicalId) ids.add(v.canonicalId);
-  };
-  const rv = canvasState.root?.data?.uipath?.variables;
-  for (const v of rv?.inputs ?? []) add(v);
-  for (const v of rv?.inputOutputs ?? []) add(v);
-  for (const v of rv?.outputs ?? []) add(v);
-  for (const d of Object.values(canvasState.diagramsById)) {
-    for (const n of d.nodes) {
-      const nv = n.data?.uipath?.variables;
-      for (const v of nv?.inputs ?? []) add(v);
-      for (const v of nv?.inputOutputs ?? []) add(v);
-      for (const v of nv?.outputs ?? []) add(v);
-      // A node's outputs each DECLARE a variable via their `var` attribute
-      // (frontend mapNodeOutputsToVariables: `id: v.var`). These variables are
-      // available to downstream nodes/edges, so they count as known. Without
-      // this, a gateway condition reading a variable written by an upstream
-      // script/task output false-positives as VARIABLE_DOES_NOT_EXIST.
-      for (const o of n.data?.uipath?.outputs ?? []) {
-        if (o.var) ids.add(o.var);
-        if (o.name) ids.add(o.name);
-        if (o.canonicalId) ids.add(o.canonicalId);
-      }
-    }
-  }
-  return ids;
-}
-
-// Convenience: all nodes / all edges across every diagram (for global checks).
-export function allNodes(canvasState) {
-  return Object.values(canvasState.diagramsById).flatMap((d) => d.nodes);
-}
-export function allEdges(canvasState) {
-  return Object.values(canvasState.diagramsById).flatMap((d) => d.edges);
-}

package/skills/uipath-maestro-bpmn/validator/package.json

@@ -1,17 +0,0 @@
-{
-  "name": "uipath-maestro-bpmn-validator",
-  "private": true,
-  "type": "module",
-  "description": "Offline semantic validator for UiPath Maestro BPMN XML. Reconstructs the PO.Frontend Node/Edge/CanvasState model from the parsed BPMN and runs all 19 PO.Frontend validation rules.",
-  "bin": {
-    "validate-bpmn": "./validate-bpmn.mjs"
-  },
-  "scripts": {
-    "test": "node test/run-tests.mjs"
-  },
-  "dependencies": {
-    "bpmn-moddle": "^9.0.2",
-    "luxon": "^3.4.4",
-    "sax": "^1.6.0"
-  }
-}