@oneuptime/common 14.0.1 → 14.0.3

package/build/dist/Types/Workflow/Templates.js

@@ -45,6 +45,7 @@ export var WorkflowTemplateCategory;
     WorkflowTemplateCategory["ScheduledMaintenance"] = "Scheduled Maintenance";
     WorkflowTemplateCategory["OnCall"] = "On-Call";
     WorkflowTemplateCategory["Scheduled"] = "On a Schedule";
+    WorkflowTemplateCategory["Jira"] = "Jira";
     WorkflowTemplateCategory["Integrations"] = "Integrations";
 })(WorkflowTemplateCategory || (WorkflowTemplateCategory = {}));
 /** Display order in the picker. Basics first, because that is where a new builder should start. */
@@ -57,6 +58,7 @@ export const WorkflowTemplateCategories = [
     WorkflowTemplateCategory.StatusPage,
     WorkflowTemplateCategory.ScheduledMaintenance,
     WorkflowTemplateCategory.Scheduled,
+    WorkflowTemplateCategory.Jira,
     WorkflowTemplateCategory.Integrations,
 ];
 /*
@@ -161,6 +163,2694 @@ const MONITOR_STATUS_TIMELINE_SELECT = {
     monitor: { name: true },
     monitorStatus: { name: true, isOfflineState: true },
 };
+/* ------------------------------- Jira ------------------------------- */
+/*
+ * The Jira templates are small workflows rather than one large one, so a team
+ * can take only the directions it wants — for incidents, for alerts, or both.
+ * They still have to agree on two things, because each one reads what another
+ * wrote.
+ *
+ * How a record and an issue find each other. Jira holds the link: an issue
+ * that belongs to an incident carries the labels `oneuptime` and
+ * `oneuptime-incident-<incident id>` (an alert's, `oneuptime-alert-<alert
+ * id>`), and every template looks the other side up by that label. Jira is
+ * the better home for it: OneUptime's customFields is one JSON value, so
+ * writing a key into it from a workflow replaces every other custom field on
+ * the record. The one exception is written at create time, when there is
+ * nothing to replace: a record created from Jira keeps the issue key in
+ * customFields.jiraIssueKey.
+ *
+ * How they avoid echoing each other. Every write in one direction is an event
+ * in the other: a comment copied into Jira arrives back as a comment_created
+ * webhook, and a note copied into OneUptime fires the note trigger. Text each
+ * side writes starts with a marker, and the template going the other way skips
+ * anything that carries it. Issue creation is guarded by the labels and by
+ * customFields.jiraIssueKey, and state changes settle on their own because a
+ * record only ever moves forward.
+ *
+ * The incident and alert versions are built from one set of builders, so the
+ * two cannot drift apart. JiraRecordKind below is everything that differs.
+ * Everything else the templates share lives in the scripts' helper block.
+ */
+/** Starts every comment OneUptime writes into Jira. Issues are guarded by their labels instead. */
+export const JIRA_SYNCED_FROM_ONEUPTIME_MARKER = "Synced from OneUptime";
+/** Starts every note, and every state change's cause, that OneUptime writes from a Jira event. */
+export const ONEUPTIME_SYNCED_FROM_JIRA_MARKER = "Synced from Jira";
+/** Carried by every Jira issue linked to a OneUptime incident or alert. */
+export const JIRA_LINK_LABEL = "oneuptime";
+/** Followed by the incident's id; the label is how either side finds the other. */
+export const JIRA_INCIDENT_LABEL_PREFIX = "oneuptime-incident-";
+/** Followed by the alert's id, for the alert versions of the templates. */
+export const JIRA_ALERT_LABEL_PREFIX = "oneuptime-alert-";
+const INCIDENT_KIND = {
+    noun: "incident",
+    Noun: "Incident",
+    plural: "incidents",
+    Plural: "Incidents",
+    upper: "INCIDENT",
+    pluralUpper: "INCIDENTS",
+    labelPrefix: JIRA_INCIDENT_LABEL_PREFIX,
+    numberField: "incidentNumberWithPrefix",
+    severityRelation: "incidentSeverity",
+    severityIdColumn: "incidentSeverityId",
+    stateRelation: "currentIncidentState",
+    stateIdColumn: "currentIncidentStateId",
+    idColumn: "incidentId",
+    timelineStateColumn: "incidentStateId",
+    dashboardPath: "incidents",
+    created: "declared",
+    Created: "Declared",
+    create: "declare",
+    Create: "Declare",
+    creating: "Declaring",
+    quietCreateFields: {
+        isVisibleOnStatusPage: false,
+        shouldStatusPageSubscribersBeNotifiedOnIncidentCreated: false,
+    },
+    quietCreateText: ", kept off status pages,",
+    editListenOn: {
+        title: true,
+        description: true,
+        incidentSeverityId: true,
+        incidentSeverity: true,
+        rootCause: true,
+        remediationNotes: true,
+    },
+    editedFieldsText: "title, severity, description, root cause or remediation notes",
+    hasPublicNotes: true,
+    otherPlural: "alerts",
+};
+const ALERT_KIND = {
+    noun: "alert",
+    Noun: "Alert",
+    plural: "alerts",
+    Plural: "Alerts",
+    upper: "ALERT",
+    pluralUpper: "ALERTS",
+    labelPrefix: JIRA_ALERT_LABEL_PREFIX,
+    numberField: "alertNumberWithPrefix",
+    severityRelation: "alertSeverity",
+    severityIdColumn: "alertSeverityId",
+    stateRelation: "currentAlertState",
+    stateIdColumn: "currentAlertStateId",
+    idColumn: "alertId",
+    timelineStateColumn: "alertStateId",
+    dashboardPath: "alerts",
+    created: "created",
+    Created: "Created",
+    create: "create",
+    Create: "Create",
+    creating: "Creating",
+    quietCreateFields: {},
+    quietCreateText: "",
+    /*
+     * An alert's root cause is written when the alert is created and cannot be
+     * edited afterwards, so it is not listened on. The comment still shows it.
+     */
+    editListenOn: {
+        title: true,
+        description: true,
+        alertSeverityId: true,
+        alertSeverity: true,
+        remediationNotes: true,
+    },
+    editedFieldsText: "title, severity, description or remediation notes",
+    hasPublicNotes: false,
+    otherPlural: "incidents",
+};
+const JIRA_BASE_URL = {
+    name: "jiraBaseUrl",
+    title: "Jira Site URL",
+    description: "Your Jira Cloud site, starting with https:// and with no trailing slash. With a scoped API token, use https://api.atlassian.com/ex/jira/<cloud id> instead.",
+    placeholder: "https://your-company.atlassian.net",
+    required: true,
+    isSecret: false,
+};
+/*
+ * Jira Cloud takes an API token as HTTP Basic auth: base64 of
+ * "email:api_token". A workflow cannot base64-encode on its own without a
+ * script, and a script that did it would return the encoded credential as an
+ * ordinary value — which is written to the run log unredacted, because only
+ * the literal content of a secret variable is scrubbed. So the variable holds
+ * the encoded value itself, and it only ever appears in request headers.
+ */
+const JIRA_BASIC_AUTH_TOKEN = {
+    name: "jiraBasicAuthToken",
+    title: "Jira API Token (base64 of email:token)",
+    description: "Create an API token at id.atlassian.com/manage-profile/security/api-tokens for a dedicated Jira user, then encode it with that user's email on one line: printf '%s' 'you@example.com:API_TOKEN' | base64 | tr -d '\\n'",
+    placeholder: "eW91QGV4YW1wbGUuY29tOkFUQVRULi4u",
+    required: true,
+    isSecret: true,
+};
+const JIRA_PROJECT_KEY = {
+    name: "jiraProjectKey",
+    title: "Jira Project Key",
+    description: "The project (space) new issues are filed in — the OPS in OPS-123.",
+    placeholder: "OPS",
+    required: true,
+    isSecret: false,
+};
+const JIRA_ISSUE_TYPE = {
+    name: "jiraIssueType",
+    title: "Jira Issue Type",
+    description: "The issue type to create, spelled exactly as it is in that project — for example Task, Bug or Incident.",
+    placeholder: "Task",
+    required: true,
+    isSecret: false,
+};
+/*
+ * Only the wording differs between the two kinds. The name, and with it
+ * whether the value is required or secret, is the same everywhere.
+ */
+const oneUptimeUrlVariable = (kind) => {
+    return {
+        name: "oneuptimeUrl",
+        title: "OneUptime URL",
+        description: `The address you open OneUptime at, used to link the Jira issue back to the ${kind.noun} — https://oneuptime.com, or your own host.`,
+        placeholder: "https://oneuptime.com",
+        required: true,
+        isSecret: false,
+    };
+};
+/*
+ * Jira Service Management shows a comment to the customer unless it is marked
+ * internal, and this comment property is how the platform API marks one. On
+ * any other kind of project it is an ordinary property nothing reads.
+ */
+const JIRA_INTERNAL_COMMENT_PROPERTY = {
+    key: "sd.public.comment",
+    value: { internal: true },
+};
+/*
+ * An object rather than JSON text: an object-valued argument is substituted
+ * with JSON escaping and handed back as an object. The argument is marked
+ * sensitive, so the whole header set is kept out of the run log.
+ */
+const jiraHeaders = () => {
+    return {
+        Authorization: "Basic {{local.variables.jiraBasicAuthToken}}",
+    };
+};
+/*
+ * Request bodies are stored as JSON text, the way the builder saves them.
+ * Serializing an object literal keeps every body valid JSON by construction;
+ * the {{...}} references inside it all sit within string values.
+ */
+const jsonText = (value) => {
+    return JSON.stringify(value, null, 2);
+};
+/*
+ * Jira Cloud's v3 API takes rich text as an Atlassian Document Format tree,
+ * not a string. Each paragraph here holds a single text node, and a text node
+ * must not be empty, so every one either starts with fixed words or holds a
+ * value the step before it guarantees is non-empty.
+ */
+const adfDocument = (paragraphs) => {
+    return { type: "doc", version: 1, content: paragraphs };
+};
+const adfParagraph = (text, href) => {
+    const node = { type: "text", text: text };
+    if (href) {
+        node["marks"] = [{ type: "link", attrs: { href: href } }];
+    }
+    return { type: "paragraph", content: [node] };
+};
+/*
+ * Finds the issue linked to a record by its label. POSTed rather than put in
+ * a query string, because references are not URL-encoded when they are
+ * substituted and JQL is full of spaces, quotes and equals signs. The older
+ * /rest/api/3/search endpoint has been removed; /search/jql replaced it, and
+ * without `fields` it returns ids only — not even the key.
+ */
+const jiraSearchBody = (props) => {
+    const body = {
+        jql: `labels = "${props.kind.labelPrefix}${props.idReference}" ORDER BY created ASC`,
+        fields: props.fields,
+        /*
+         * Two, not one: the scripts need to see a second match to refuse it. A
+         * clone copies labels, and anyone who can edit an issue the token can see
+         * can add one, so "the first match" could be an issue that is not the
+         * record's — and private notes would be posted to it.
+         */
+        maxResults: 2,
+    };
+    if (props.expandTransitions) {
+        body["expand"] = "transitions";
+    }
+    return jsonText(body);
+};
+/*
+ * Every Jira script starts with the same helper block, so each one can be read
+ * and edited on its own. Two rules hold for all of them:
+ *
+ *   - No double braces anywhere in the source. The script is an argument like
+ *     any other, so a {{...}} in it would be substituted before it runs. Where
+ *     the code needs the characters, it builds them ('{' + '{').
+ *   - Text that came from the other system goes through defuse() before it is
+ *     returned. A later step quotes these return values into its own
+ *     arguments, and text that still held a {{...}} would be substituted there
+ *     — a Jira comment could name a secret variable and have it filled in.
+ *
+ * isLinked recognises both kinds of link label, so an issue that is already
+ * linked when its event arrives — one OneUptime filed for an incident, say —
+ * is never also made an alert, or the other way round. It cannot separate the
+ * two create-from-Jira templates when both receive the same new issue: each
+ * checks before either labels it. Their Jira webhook filters must not overlap,
+ * and their descriptions say so.
+ */
+const jiraScript = (kind, body) => {
+    const helpers = String.raw `// ---- Shared by the Jira templates ----
+const FROM_ONEUPTIME = ${JSON.stringify(JIRA_SYNCED_FROM_ONEUPTIME_MARKER)};
+const FROM_JIRA = ${JSON.stringify(ONEUPTIME_SYNCED_FROM_JIRA_MARKER)};
+const LINK_LABEL = ${JSON.stringify(JIRA_LINK_LABEL)};
+const ${kind.upper}_LABEL_PREFIX = ${JSON.stringify(kind.labelPrefix)};
+// The label prefixes of every kind of record an issue can be linked to.
+const LINKED_LABEL_PREFIXES = ${JSON.stringify([
+        JIRA_INCIDENT_LABEL_PREFIX,
+        JIRA_ALERT_LABEL_PREFIX,
+    ])};
+const ISSUE_KEY = /^[A-Za-z][A-Za-z0-9_]*-[0-9]+$/;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+
+// Another step's output quoted into the arguments arrives as JSON text.
+const readJson = (value) => {
+  if (typeof value !== 'string') return value === undefined ? null : value;
+  try { return JSON.parse(value); } catch (error) { return null; }
+};
+const asText = (value) => (typeof value === 'string' ? value : typeof value === 'number' ? String(value) : '');
+// OneUptime ids, names and dates are serialized as { _type, value }.
+const valueOf = (value) => (value && typeof value === 'object' ? asText(value.value) : asText(value));
+// Drops the control characters JSON and Jira reject, keeping tabs and line breaks.
+const clean = (value) => Array.from(asText(value)).filter((c) => {
+  const code = c.charCodeAt(0);
+  return code === 9 || code === 10 || (code >= 32 && code !== 127);
+}).join('');
+const oneLine = (value) => clean(value).replace(/\s+/g, ' ').trim();
+const limit = (value, max) => (value.length > max ? value.slice(0, max - 1) + '…' : value);
+// Breaks up double braces so a later step cannot read the text as a reference.
+const defuse = (value) => {
+  let text = value;
+  while (text.indexOf('{' + '{') !== -1) text = text.split('{' + '{').join('{ {');
+  while (text.indexOf('}' + '}') !== -1) text = text.split('}' + '}').join('} }');
+  return text;
+};
+// Atlassian Document Format flattened to text. Wiki-markup strings pass through.
+const plainText = (value) => {
+  if (typeof value === 'string') return value;
+  if (!value || typeof value !== 'object') return '';
+  const children = Array.isArray(value.content) ? value.content.map(plainText) : [];
+  return asText(value.text) + (value.type === 'hardBreak' ? '\n' : '') + children.join(value.type === 'doc' ? '\n' : '');
+};
+const displayName = (user) => (user && typeof user === 'object' ? asText(user.displayName) || valueOf(user.name) : '');
+// The ${kind.noun} id in a linked issue's ${kind.labelPrefix}<id> label.
+const ${kind.noun}IdFromLabels = (labels) => {
+  for (const label of Array.isArray(labels) ? labels : []) {
+    const text = asText(label).toLowerCase();
+    const id = text.slice(${kind.upper}_LABEL_PREFIX.length);
+    if (text.indexOf(${kind.upper}_LABEL_PREFIX) === 0 && UUID.test(id)) return id;
+  }
+  return '';
+};
+const isLinked = (labels) => (Array.isArray(labels) ? labels : []).some((label) => {
+  const text = asText(label).toLowerCase();
+  return text === LINK_LABEL || LINKED_LABEL_PREFIXES.some((prefix) => text.indexOf(prefix) === 0);
+});
+// https://your-company.atlassian.net, read off an issue's own REST URL.
+const siteOf = (self) => {
+  const match = asText(self).match(/^https?:\/\/[^/]+/);
+  return match ? match[0] : '';
+};
+const issueLink = (self, issueKey) => {
+  const site = siteOf(self);
+  return site ? '[' + issueKey + '](' + site + '/browse/' + issueKey + ')' : issueKey;
+};
+// A bare "#12" says nothing about what it numbers, so it gets a name: "${kind.Noun} #12".
+const numbered = (value) => {
+  const text = asText(value);
+  return text.charAt(0) === '#' ? ${JSON.stringify(kind.Noun)} + ' ' + text : text;
+};
+// Reasons can quote the other system's text, so they are defused like everything else.
+const skip = (reason) => ({ proceed: false, reason: defuse(asText(reason)) });
+// The one issue a label search found for an ${kind.noun}. More than one means a clone or
+// a hand-added label is also claiming the ${kind.noun}, and guessing would post to the
+// wrong issue, so the step stops and says which issues to fix.
+const linkedIssue = (search, ${kind.noun}Id) => {
+  const label = ${kind.upper}_LABEL_PREFIX + ${kind.noun}Id;
+  const issues = (search && Array.isArray(search.issues) ? search.issues : [])
+    .filter((issue) => issue && ISSUE_KEY.test(asText(issue.key)));
+  if (!issues.length) return { reason: 'No Jira issue is labelled ' + label + ', or the Jira credentials cannot see it.' };
+  if (issues.length > 1) {
+    return { reason: 'More than one Jira issue is labelled ' + label + ' (' + issues.map((issue) => asText(issue.key)).join(', ') + '). A cloned issue copies the label: remove it from every issue except the one filed for the ${kind.noun}.' };
+  }
+  return { issue: issues[0], issueKey: asText(issues[0].key) };
+};
+`;
+    return `${helpers}\n// ---- What this step does ----\n${body.trim()}\n`;
+};
+/*
+ * OneUptime -> Jira: shapes a new record into an issue's summary and
+ * description. The issue's fields themselves are in the API step, where they
+ * are easiest to extend.
+ */
+const jiraPrepareIssueScript = (kind) => {
+    const r = kind.noun;
+    return jiraScript(kind, String.raw `
+// Turns the new ${r} into the Jira issue's summary and description.
+// Edit the wording here. The issue's other fields are in the "Create Jira issue" step.
+// Private ${kind.plural} stay in OneUptime. Set this to true to file them in Jira anyway.
+const SYNC_PRIVATE_${kind.pluralUpper} = false;
+
+const ${r} = readJson(args.${r}) || {};
+const customFields = ${r}.customFields || {};
+const number = numbered(${r}.${kind.numberField}) || 'The ${r}';
+
+// The label is the only link between the two, so there is no issue without an id.
+if (!UUID.test(asText(${r}._id))) return skip('The trigger did not hand over an ${r} id.');
+
+if (${r}.isPrivate === true && !SYNC_PRIVATE_${kind.pluralUpper}) {
+  return skip(number + ' is a private ${r}, so no Jira issue was created.');
+}
+
+// ${kind.Created} from a Jira issue: it already has one, and opening another would loop.
+if (asText(customFields.jiraIssueKey)) {
+  return skip(number + ' was ${kind.created} from Jira issue ' + asText(customFields.jiraIssueKey) + ', so no new issue was created.');
+}
+
+const severity = ${r}.${kind.severityRelation} ? oneLine(${r}.${kind.severityRelation}.name) : '';
+const state = ${r}.${kind.stateRelation} ? oneLine(${r}.${kind.stateRelation}.name) : '';
+const description = clean(${r}.description).trim();
+
+const lines = [number + ' was ${kind.created} in OneUptime.'];
+if (severity) lines.push('Severity: ' + severity);
+if (state) lines.push('State: ' + state);
+if (description) lines.push('', description);
+// A monitor fills these in when it raises the ${r}; often they say more than the description.
+const rootCause = clean(${r}.rootCause).trim();
+if (rootCause) lines.push('', 'Root cause:', limit(rootCause, 5000));
+const remediation = clean(${r}.remediationNotes).trim();
+if (remediation) lines.push('', 'Remediation:', limit(remediation, 5000));
+
+let oneUptimeUrl = oneLine(args.oneuptimeUrl).replace(/\/+$/, '');
+if (!/^https?:\/\//i.test(oneUptimeUrl)) oneUptimeUrl = 'https://' + oneUptimeUrl;
+
+return {
+  proceed: true,
+  // Jira rejects a summary over 255 characters or with a line break in it.
+  summary: limit(defuse(oneLine('[OneUptime] ' + number + ': ' + (oneLine(${r}.title) || 'Untitled ${r}'))), 255),
+  description: limit(defuse(lines.join('\n')), 30000),
+  ${r}Label: ${kind.upper}_LABEL_PREFIX + asText(${r}._id).toLowerCase(),
+  ${r}Url: oneUptimeUrl + '/dashboard/' + valueOf(${r}.projectId) + '/${kind.dashboardPath}/' + asText(${r}._id),
+};
+`);
+};
+/*
+ * OneUptime -> Jira: picks the transition for the record's new state out of
+ * the transitions the search returned for the linked issue.
+ */
+const jiraPlanTransitionScript = (kind) => {
+    const r = kind.noun;
+    return jiraScript(kind, String.raw `
+// Picks the Jira transition that matches the ${r}'s new state.
+// To map a OneUptime state to one Jira status by name, list it here, for example
+// { Resolved: 'Resolved', Monitoring: 'In Review' }. Everything else goes by meaning:
+// acknowledged moves the issue to an In Progress status, and resolved to a Done one.
+// A workflow with several Done statuses, such as Jira Service Management's Resolved,
+// Canceled and Closed, needs the one to use named here.
+const STATE_TO_JIRA_STATUS = {};
+// Private ${kind.plural} stay in OneUptime. Set this to true to sync them anyway.
+const SYNC_PRIVATE_${kind.pluralUpper} = false;
+// Going by meaning, a status with one of these names wins, and a status matching
+// NEVER_GUESS is only ever used when STATE_TO_JIRA_STATUS names it.
+const PREFERRED_STATUS = { done: /^(done|resolved|closed|complete|completed|fixed)$/i, indeterminate: /^(in progress|work in progress)$/i };
+const NEVER_GUESS = /cancel|declin|reject|won.?t|duplicate|obsolete|waiting|pending|escalat|on hold|blocked/i;
+// Jira's status categories, in the order work moves through them.
+const CATEGORY_RANK = { new: 0, indeterminate: 1, done: 2 };
+
+const ${r} = readJson(args.${r}) || {};
+const search = readJson(args.search) || {};
+const state = ${r}.${kind.stateRelation} || {};
+const stateName = oneLine(state.name);
+const number = numbered(${r}.${kind.numberField}) || 'The ${r}';
+
+if (${r}.isPrivate === true && !SYNC_PRIVATE_${kind.pluralUpper}) {
+  return skip(number + ' is a private ${r}, so its Jira issue was not moved.');
+}
+
+const wantedName = oneLine(STATE_TO_JIRA_STATUS[stateName]);
+const wantedCategory = wantedName ? '' : state.isResolvedState === true ? 'done' : state.isAcknowledgedState === true ? 'indeterminate' : '';
+if (!wantedName && !wantedCategory) {
+  return skip(number + ' moved to ' + (stateName || 'a new state') + ', which has no Jira status mapped to it.');
+}
+const wanted = wantedName || (wantedCategory === 'done' ? 'a Done status' : 'an In Progress status');
+
+const found = linkedIssue(search, asText(${r}._id));
+if (!found.issue) return skip(found.reason);
+const issueKey = found.issueKey;
+
+// Match on the status a transition leads to, never on the transition's own name:
+// the two differ, and transition ids differ between Jira workflows.
+const matches = (status) => Boolean(status) && (wantedName
+  ? oneLine(status.name).toLowerCase() === wantedName.toLowerCase()
+  : Boolean(status.statusCategory) && status.statusCategory.key === wantedCategory);
+const rankOf = (status) => {
+  const rank = status && status.statusCategory ? CATEGORY_RANK[asText(status.statusCategory.key)] : undefined;
+  return typeof rank === 'number' ? rank : -1;
+};
+
+const current = (found.issue.fields && found.issue.fields.status) || {};
+const currentName = oneLine(current.name) || 'its status';
+if (matches(current)) return skip('Jira issue ' + issueKey + ' is already ' + currentName + '.');
+
+// Like the ${r}, the issue only moves forward: acknowledging an ${r} whose
+// issue someone already closed leaves the issue closed.
+if (!wantedName && rankOf(current) >= CATEGORY_RANK[wantedCategory]) {
+  return skip('Jira issue ' + issueKey + ' is already ' + currentName + ', so it was not moved back to ' + wanted + '.');
+}
+
+const score = (transition) => {
+  if (wantedName) return 0;
+  const name = oneLine(transition.to.name);
+  if (PREFERRED_STATUS[wantedCategory].test(name)) return 0;
+  return NEVER_GUESS.test(name) ? 2 : 1;
+};
+const reachable = (Array.isArray(found.issue.transitions) ? found.issue.transitions : [])
+  .filter((transition) => transition && transition.isAvailable !== false && matches(transition.to));
+const forward = reachable
+  .filter((transition) => rankOf(transition.to) < 0 || rankOf(current) < 0 || rankOf(transition.to) >= rankOf(current));
+if (wantedName && !forward.length) {
+  return skip(reachable.length
+    ? 'Jira issue ' + issueKey + ' is already ' + currentName + ', so it was not moved back to ' + wantedName + '.'
+    : 'Jira issue ' + issueKey + ' has no transition from ' + currentName + ' to ' + wantedName + '.');
+}
+const candidates = forward
+  .map((transition) => ({ transition: transition, score: score(transition) }))
+  .filter((candidate) => candidate.score < 2)
+  // Prefer a transition without a screen: those never ask for extra fields.
+  .sort((a, b) => a.score - b.score || (a.transition.hasScreen ? 1 : 0) - (b.transition.hasScreen ? 1 : 0));
+if (!candidates.length) {
+  return skip('Jira issue ' + issueKey + ' has no transition from ' + currentName + ' to ' + wanted + ' that can be chosen without naming it in STATE_TO_JIRA_STATUS.');
+}
+
+// Several different statuses fit equally well. Guessing could, say, cancel a request.
+const best = candidates[0];
+const tied = candidates.filter((candidate) => candidate.score === best.score)
+  .map((candidate) => oneLine(candidate.transition.to.name))
+  .filter((name, index, names) => names.map((other) => other.toLowerCase()).indexOf(name.toLowerCase()) === index);
+if (tied.length > 1) {
+  return skip('Jira issue ' + issueKey + ' could move to ' + tied.join(' or ') + ' for ' + wanted + '. Name the one to use in STATE_TO_JIRA_STATUS.');
+}
+
+return {
+  proceed: true,
+  issueKey: issueKey,
+  transitionId: defuse(asText(best.transition.id)),
+  jiraStatus: defuse(oneLine(best.transition.to.name)) || wanted,
+  reason: number + ' is ' + stateName + ' in OneUptime.',
+};
+`);
+};
+/*
+ * OneUptime -> Jira: the comment for a new private or public note. The
+ * templates differ only in the trigger and in what they call the note.
+ */
+const jiraNoteCommentScript = (kind, noteKind) => {
+    const r = kind.noun;
+    return jiraScript(kind, String.raw `
+// Writes the Jira comment for a new ${noteKind}.
+const NOTE_KIND = ${JSON.stringify(noteKind)};
+// Notes on private ${kind.plural} stay in OneUptime. Set this to true to post them anyway.
+const SYNC_PRIVATE_${kind.pluralUpper} = false;
+
+const note = readJson(args.note) || {};
+const search = readJson(args.search) || {};
+const text = clean(note.note).trim();
+const number = (note.${r} && numbered(note.${r}.${kind.numberField})) || 'the ${r}';
+if (note.${r} && note.${r}.isPrivate === true && !SYNC_PRIVATE_${kind.pluralUpper}) {
+  return skip('The note is on ' + number + ', a private ${r}, so it was not posted to Jira.');
+}
+if (!text) return skip('The note is empty, so there is nothing to post.');
+
+// Notes copied in from Jira carry this marker. Posting them back would loop.
+if (text.indexOf(FROM_JIRA) !== -1) {
+  return skip('This note came from Jira, so it was not posted back.');
+}
+
+const found = linkedIssue(search, valueOf(note.${kind.idColumn}));
+if (!found.issue) return skip(found.reason);
+const issueKey = found.issueKey;
+
+const author = displayName(note.createdByUser);
+const heading = FROM_ONEUPTIME + ': ' + NOTE_KIND + ' on ' + number + (author ? ' by ' + author : '') + '.';
+
+return {
+  proceed: true,
+  issueKey: issueKey,
+  comment: limit(defuse(heading + '\n\n' + text), 30000),
+};
+`);
+};
+/*
+ * OneUptime -> Jira: a comment describing the record as it now stands. The
+ * update trigger hands over the record's current values, not what changed, so
+ * the comment is a snapshot of the fields worth knowing about.
+ */
+const jiraUpdateCommentScript = (kind) => {
+    const r = kind.noun;
+    return jiraScript(kind, String.raw `
+// Writes a Jira comment describing the ${r} as it now stands.
+// Private ${kind.plural} stay in OneUptime. Set this to true to post their changes anyway.
+const SYNC_PRIVATE_${kind.pluralUpper} = false;
+
+const ${r} = readJson(args.${r}) || {};
+const search = readJson(args.search) || {};
+const number = numbered(${r}.${kind.numberField}) || 'The ${r}';
+
+if (${r}.isPrivate === true && !SYNC_PRIVATE_${kind.pluralUpper}) {
+  return skip(number + ' is a private ${r}, so its changes were not posted to Jira.');
+}
+
+const found = linkedIssue(search, asText(${r}._id));
+if (!found.issue) return skip(found.reason);
+const issueKey = found.issueKey;
+
+const lines = [FROM_ONEUPTIME + ': ' + number + ' was updated.'];
+const add = (label, value, max) => {
+  const text = clean(value).trim();
+  if (text) lines.push(label + ': ' + limit(text, max));
+};
+add('Title', ${r}.title, 500);
+add('Severity', ${r}.${kind.severityRelation} && ${r}.${kind.severityRelation}.name, 200);
+add('State', ${r}.${kind.stateRelation} && ${r}.${kind.stateRelation}.name, 200);
+add('Root cause', ${r}.rootCause, 5000);
+add('Remediation', ${r}.remediationNotes, 5000);
+add('Description', ${r}.description, 5000);
+
+return {
+  proceed: true,
+  issueKey: issueKey,
+  comment: limit(defuse(lines.join('\n')), 30000),
+};
+`);
+};
+/*
+ * Jira -> OneUptime: turns a jira:issue_created webhook into the fields of a
+ * new record, choosing a severity from the issue's priority.
+ */
+const jiraPrepareRecordScript = (kind) => {
+    const r = kind.noun;
+    return jiraScript(kind, String.raw `
+// Turns a Jira "issue created" event into a OneUptime ${r}.
+// Jira priority to OneUptime severity: 0 is your most severe severity and 2 your
+// least, with the ones in between spread across the range. Priorities that are
+// not listed land in the middle.
+const PRIORITY_RANK = { highest: 0, blocker: 0, critical: 0, high: 0, major: 1, medium: 1, low: 2, minor: 2, lowest: 2, trivial: 2 };
+
+const payload = readJson(args.payload) || {};
+const event = asText(payload.webhookEvent);
+const issue = payload.issue || {};
+const fields = issue.fields || {};
+const issueKey = asText(issue.key);
+
+if (event !== 'jira:issue_created') {
+  return skip(event ? 'Ignored a ' + event + ' event: this workflow only handles jira:issue_created.' : 'The request was not a Jira webhook event, so it was ignored.');
+}
+if (!ISSUE_KEY.test(issueKey)) return skip('The event did not name a Jira issue key.');
+
+// Issues OneUptime opened are labelled. ${kind.creating} an ${r} for one would loop.
+if (isLinked(fields.labels)) {
+  return skip('Jira issue ' + issueKey + ' is already linked to OneUptime, so no ${r} was ${kind.created}.');
+}
+
+const found = readJson(args.severities);
+const severities = (Array.isArray(found) ? found : [])
+  .filter((severity) => severity && asText(severity._id))
+  .sort((a, b) => Number(a.order) - Number(b.order));
+if (!severities.length) return skip('This project has no ${r} severities to choose from.');
+
+const priority = fields.priority ? oneLine(fields.priority.name) : '';
+const rankValue = PRIORITY_RANK[priority.toLowerCase()];
+const rank = typeof rankValue === 'number' ? Math.min(Math.max(rankValue, 0), 2) : 1;
+const severity = severities[Math.round((rank / 2) * (severities.length - 1))];
+
+const reporter = displayName(fields.reporter) || displayName(payload.user);
+const lines = ['${kind.Created} from Jira issue ' + issueLink(issue.self, issueKey) + '.'];
+if (priority) lines.push('Priority: ' + priority);
+if (reporter) lines.push('Reported by: ' + reporter);
+const description = clean(plainText(fields.description)).trim();
+if (description) lines.push('', description);
+
+return {
+  proceed: true,
+  issueKey: issueKey,
+  severityName: oneLine(severity.name),
+  ${kind.severityIdColumn}: asText(severity._id),
+  title: limit(defuse(oneLine(fields.summary) || 'Jira issue ' + issueKey), 500),
+  description: limit(defuse(lines.join('\n')), 20000),
+};
+`);
+};
+/*
+ * Jira -> OneUptime: the create template's second look at the issue, this
+ * time as Jira has it rather than as the webhook described it.
+ */
+const jiraConfirmUnlinkedScript = (kind) => {
+    return jiraScript(kind, String.raw `
+// Checks the issue as Jira has it now, not as the webhook described it: anyone with
+// this workflow's URL can describe any issue, and a delivery Jira retries arrives
+// after the first one has already labelled the issue.
+const issue = readJson(args.issue) || {};
+const issueKey = asText(issue.key);
+if (!ISSUE_KEY.test(issueKey)) return skip('Jira did not return the issue, so no ${kind.noun} was ${kind.created}.');
+if (isLinked(issue.fields && issue.fields.labels)) {
+  return skip('Jira issue ' + issueKey + ' is already linked to OneUptime, so no ${kind.noun} was ${kind.created}.');
+}
+return { proceed: true, issueKey: issueKey };
+`);
+};
+/*
+ * Jira -> OneUptime: keeps a jira:issue_updated webhook only when the issue's
+ * status moved and the issue is linked to a record of this kind.
+ */
+const jiraReadStatusChangeScript = (kind) => {
+    const r = kind.noun;
+    return jiraScript(kind, String.raw `
+// Reads a Jira "issue updated" event and keeps it only if the issue's status moved.
+const payload = readJson(args) || {};
+const event = asText(payload.webhookEvent);
+const issue = payload.issue || {};
+const fields = issue.fields || {};
+const issueKey = asText(issue.key);
+
+if (event !== 'jira:issue_updated') {
+  return skip(event ? 'Ignored a ' + event + ' event: this workflow only handles jira:issue_updated.' : 'The request was not a Jira webhook event, so it was ignored.');
+}
+if (!ISSUE_KEY.test(issueKey)) return skip('The event did not name a Jira issue key.');
+
+// The status item is not always first: resolving an issue lists the resolution before it.
+const items = payload.changelog && Array.isArray(payload.changelog.items) ? payload.changelog.items : [];
+const moved = items.some((item) => item && (asText(item.fieldId) === 'status' || asText(item.field).toLowerCase() === 'status'));
+if (!moved) return skip('Jira issue ' + issueKey + ' changed, but its status did not.');
+
+const ${r}Id = ${r}IdFromLabels(fields.labels);
+if (!${r}Id) {
+  return skip('Jira issue ' + issueKey + ' is not linked to an ${r}: it has no ' + ${kind.upper}_LABEL_PREFIX + '<id> label.');
+}
+
+const status = fields.status || {};
+return {
+  proceed: true,
+  ${r}Id: ${r}Id,
+  issueKey: issueKey,
+  // Names are Jira users' text, and the next script receives them quoted into its arguments.
+  jiraStatus: defuse(oneLine(status.name)),
+  jiraStatusCategory: status.statusCategory ? asText(status.statusCategory.key) : '',
+  changedBy: defuse(oneLine(displayName(payload.user))),
+};
+`);
+};
+/*
+ * Jira -> OneUptime: maps the issue's new status onto a record state, and
+ * only ever moves the record forward.
+ */
+const jiraDecideStateScript = (kind) => {
+    const r = kind.noun;
+    return jiraScript(kind, String.raw `
+// Maps the Jira issue's new status onto a OneUptime ${r} state.
+// To map one Jira status to one state by name, list it here, for example
+// { 'In Review': 'Monitoring' }. Names listed here win over the categories below.
+const JIRA_STATUS_TO_STATE = {};
+// Otherwise the status category decides: In Progress acknowledges the ${r} and
+// Done resolves it. To Do maps to nothing, because an ${r} never moves backwards.
+const CATEGORY_TO_STATE_FLAG = { indeterminate: 'isAcknowledgedState', done: 'isResolvedState' };
+
+const event = readJson(args.event) || {};
+const ${r} = readJson(args.${r});
+const states = readJson(args.states);
+if (!${r} || !asText(${r}._id)) {
+  return skip('No ${r} with id ' + asText(event.${r}Id) + ' exists in this project.');
+}
+
+const number = numbered(${r}.${kind.numberField}) || 'The ${r}';
+const jiraStatus = asText(event.jiraStatus) || 'a new status';
+const list = Array.isArray(states) ? states : [];
+const wantedName = oneLine(JIRA_STATUS_TO_STATE[asText(event.jiraStatus)]).toLowerCase();
+const flag = asText(CATEGORY_TO_STATE_FLAG[asText(event.jiraStatusCategory)]);
+const target = wantedName
+  ? list.find((state) => state && oneLine(state.name).toLowerCase() === wantedName)
+  : flag ? list.find((state) => state && state[flag] === true) : null;
+if (!target) {
+  return skip('Jira issue ' + asText(event.issueKey) + ' moved to ' + jiraStatus + ', which does not map to a OneUptime state.');
+}
+
+// An ${r} only moves forward, so an earlier or equal state changes nothing. This
+// is also what settles the echo after the OneUptime-to-Jira template moved the issue.
+const current = ${r}.${kind.stateRelation} || {};
+if (Number(target.order) <= Number(current.order)) {
+  return skip(number + ' is already ' + (oneLine(current.name) || 'past that state') + ', so Jira issue ' + asText(event.issueKey) + ' moving to ' + jiraStatus + ' changes nothing.');
+}
+
+return {
+  proceed: true,
+  ${r}Id: asText(${r}._id),
+  stateId: asText(target._id),
+  stateName: oneLine(target.name),
+  rootCause: limit(defuse(FROM_JIRA + ': issue ' + asText(event.issueKey) + ' moved to ' + jiraStatus + (event.changedBy ? ' by ' + oneLine(event.changedBy) : '') + '.'), 1000),
+};
+`);
+};
+/*
+ * Jira -> OneUptime: turns a comment_created webhook into the text of a
+ * private note.
+ */
+const jiraReadCommentScript = (kind) => {
+    return jiraScript(kind, String.raw `
+// Reads a Jira comment event and turns it into the text of a OneUptime note.
+// Add 'comment_updated' to also copy edits; each edit then becomes a new note.
+const EVENTS = ['comment_created'];
+
+const payload = readJson(args) || {};
+const event = asText(payload.webhookEvent);
+const comment = payload.comment || {};
+const issue = payload.issue || {};
+const issueKey = asText(issue.key);
+
+if (EVENTS.indexOf(event) === -1) {
+  return skip(event ? 'Ignored a ' + event + ' event: this workflow only handles ' + EVENTS.join(', ') + '.' : 'The request was not a Jira webhook event, so it was ignored.');
+}
+if (!ISSUE_KEY.test(issueKey)) return skip('The event did not name a Jira issue key.');
+
+const body = clean(plainText(comment.body)).trim();
+if (!body) return skip('The comment on Jira issue ' + issueKey + ' is empty.');
+
+// Comments OneUptime posted carry this marker. Copying them back would loop.
+if (body.indexOf(FROM_ONEUPTIME) !== -1) {
+  return skip('This comment was posted by OneUptime, so it was not copied back.');
+}
+
+const author = oneLine(displayName(comment.author)) || 'Someone';
+return {
+  proceed: true,
+  issueKey: issueKey,
+  note: limit(defuse(FROM_JIRA + ': ' + author + ' commented on ' + issueLink(issue.self, issueKey) + '.\n\n' + body), 30000),
+};
+`);
+};
+/*
+ * Jira -> OneUptime: comment webhooks carry the issue's summary and status but
+ * not its labels, so the comment template fetches the issue and reads the
+ * link from the response.
+ */
+const jiraFindLinkedRecordScript = (kind) => {
+    const r = kind.noun;
+    return jiraScript(kind, String.raw `
+// Finds the ${r} a Jira issue is linked to, from its ${kind.labelPrefix}<id> label.
+const comment = readJson(args.comment) || {};
+const issue = readJson(args.issue) || {};
+const ${r}Id = ${r}IdFromLabels(issue.fields && issue.fields.labels);
+if (!${r}Id) {
+  return skip('Jira issue ' + asText(comment.issueKey) + ' is not linked to an ${r}: it has no ' + ${kind.upper}_LABEL_PREFIX + '<id> label.');
+}
+return { proceed: true, ${r}Id: ${r}Id };
+`);
+};
+/*
+ * Jira -> OneUptime: lists what changed on a linked issue, for a private
+ * note. Status is left to the status template.
+ */
+const jiraReadIssueChangesScript = (kind) => {
+    const r = kind.noun;
+    return jiraScript(kind, String.raw `
+// Reads a Jira "issue updated" event and lists what changed, for a OneUptime note.
+// Fields whose changes are not worth a note. Status is left to the status template.
+const IGNORED_FIELDS = ['status', 'resolution', 'resolutiondate', 'rank', 'timespent', 'timeestimate', 'aggregatetimespent', 'aggregatetimeestimate', 'worklogid', 'lastviewed'];
+
+const payload = readJson(args) || {};
+const event = asText(payload.webhookEvent);
+const issue = payload.issue || {};
+const fields = issue.fields || {};
+const issueKey = asText(issue.key);
+
+if (event !== 'jira:issue_updated') {
+  return skip(event ? 'Ignored a ' + event + ' event: this workflow only handles jira:issue_updated.' : 'The request was not a Jira webhook event, so it was ignored.');
+}
+if (!ISSUE_KEY.test(issueKey)) return skip('The event did not name a Jira issue key.');
+
+const ${r}Id = ${r}IdFromLabels(fields.labels);
+if (!${r}Id) {
+  return skip('Jira issue ' + issueKey + ' is not linked to an ${r}: it has no ' + ${kind.upper}_LABEL_PREFIX + '<id> label.');
+}
+
+// Adding the oneuptime labels is how an issue gets linked, not a change worth a note.
+const labelsIn = (value) => asText(value).split(' ').filter(Boolean);
+const onlyLinkLabels = (item) => {
+  const before = labelsIn(item.fromString);
+  const after = labelsIn(item.toString);
+  const changed = after.filter((label) => before.indexOf(label) === -1)
+    .concat(before.filter((label) => after.indexOf(label) === -1));
+  return changed.length > 0 && changed.every((label) => isLinked([label]));
+};
+
+const items = payload.changelog && Array.isArray(payload.changelog.items) ? payload.changelog.items : [];
+// Custom fields such as Rank arrive with a customfield_ id, so check the display name too.
+const changes = items.filter((item) => {
+  if (!item) return false;
+  const names = [asText(item.fieldId), asText(item.field)].map((name) => name.toLowerCase());
+  if (names.some((name) => IGNORED_FIELDS.indexOf(name) !== -1)) return false;
+  return !(names.indexOf('labels') !== -1 && onlyLinkLabels(item));
+});
+if (!changes.length) return skip('Nothing that changed on Jira issue ' + issueKey + ' is worth a note.');
+
+const show = (value) => {
+  const text = oneLine(value);
+  return text ? limit(text, 300) : '(empty)';
+};
+const lines = changes.map((item) => '- ' + (oneLine(item.field) || oneLine(item.fieldId)) + ': ' + show(item.fromString) + ' → ' + show(item.toString));
+const who = oneLine(displayName(payload.user)) || 'Someone';
+
+return {
+  proceed: true,
+  ${r}Id: ${r}Id,
+  issueKey: issueKey,
+  note: limit(defuse(FROM_JIRA + ': ' + who + ' updated ' + issueLink(issue.self, issueKey) + '.\n\n' + lines.join('\n')), 30000),
+};
+`);
+};
+/** The If / Else every Jira template uses to act on a script's decision. */
+const proceedCondition = (componentId) => {
+    return {
+        "input-1-type": ConditionValueType.Boolean,
+        "input-1": `{{local.components.${componentId}.returnValues.returnValue.proceed}}`,
+        operator: ConditionOperator.EqualTo,
+        "input-2-type": ConditionValueType.Boolean,
+        "input-2": true,
+    };
+};
+/* ----------------------- OneUptime -> Jira ----------------------- */
+const jiraCreateIssueTemplate = (kind) => {
+    const r = kind.noun;
+    const trigger = `${r}-on-create-1`;
+    return {
+        id: `jira-create-issue-for-${r}`,
+        name: `Create a Jira issue when an ${r} is ${kind.created}`,
+        description: `Files a Jira issue for every new ${r}, labelled so the other Jira templates can find it again.`,
+        teaches: `How to call a REST API with Basic auth, and how a label on the issue becomes the link back to the ${r}.`,
+        category: WorkflowTemplateCategory.Jira,
+        icon: IconProp.Ticket,
+        workflowName: `Create Jira issue for new ${r}`,
+        workflowDescription: `Creates a Jira issue whenever an ${r} is ${kind.created}, labelled ${kind.labelPrefix}<id>. ${kind.Plural} that were ${kind.created} from Jira are skipped.`,
+        variables: [
+            JIRA_BASE_URL,
+            JIRA_BASIC_AUTH_TOKEN,
+            JIRA_PROJECT_KEY,
+            JIRA_ISSUE_TYPE,
+            oneUptimeUrlVariable(kind),
+        ],
+        graph: {
+            nodes: [
+                {
+                    componentId: trigger,
+                    metadataId: `${r}-on-create`,
+                    componentType: ComponentType.Trigger,
+                    position: { x: 100, y: 100 },
+                    args: {
+                        select: {
+                            _id: true,
+                            projectId: true,
+                            title: true,
+                            description: true,
+                            [kind.numberField]: true,
+                            isPrivate: true,
+                            customFields: true,
+                            rootCause: true,
+                            remediationNotes: true,
+                            [kind.severityRelation]: { name: true },
+                            [kind.stateRelation]: { name: true },
+                        },
+                    },
+                },
+                {
+                    componentId: "prepare-issue-1",
+                    metadataId: ComponentID.JavaScriptCode,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 300 },
+                    args: {
+                        code: jiraPrepareIssueScript(kind),
+                        arguments: jsonText({
+                            oneuptimeUrl: "{{local.variables.oneuptimeUrl}}",
+                            [r]: `{{local.components.${trigger}.returnValues.model}}`,
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-prepare-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 600, y: 300 },
+                    args: {
+                        value: "❌ Could not prepare the Jira issue: {{local.components.prepare-issue-1.returnValues.error}}",
+                    },
+                },
+                {
+                    componentId: "if-create-1",
+                    metadataId: ComponentID.IfElse,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 500 },
+                    args: proceedCondition("prepare-issue-1"),
+                },
+                {
+                    componentId: "log-skipped",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 350, y: 700 },
+                    args: {
+                        value: "ℹ️ {{local.components.prepare-issue-1.returnValues.returnValue.reason}}",
+                    },
+                },
+                {
+                    componentId: "create-issue-1",
+                    metadataId: ComponentID.ApiPost,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 700 },
+                    args: {
+                        url: "{{local.variables.jiraBaseUrl}}/rest/api/3/issue",
+                        "request-headers": jiraHeaders(),
+                        "request-body": jsonText({
+                            fields: {
+                                project: { key: "{{local.variables.jiraProjectKey}}" },
+                                issuetype: { name: "{{local.variables.jiraIssueType}}" },
+                                summary: "{{local.components.prepare-issue-1.returnValues.returnValue.summary}}",
+                                labels: [
+                                    JIRA_LINK_LABEL,
+                                    `{{local.components.prepare-issue-1.returnValues.returnValue.${r}Label}}`,
+                                ],
+                                description: adfDocument([
+                                    adfParagraph("{{local.components.prepare-issue-1.returnValues.returnValue.description}}"),
+                                    adfParagraph(`Open this ${r} in OneUptime`, `{{local.components.prepare-issue-1.returnValues.returnValue.${r}Url}}`),
+                                ]),
+                            },
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-created",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 900 },
+                    args: {
+                        value: `✅ Created Jira issue {{local.components.create-issue-1.returnValues.response-body.key}} for {{local.components.${trigger}.returnValues.model.${kind.numberField}}}.`,
+                    },
+                },
+                {
+                    componentId: "log-create-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 900 },
+                    args: {
+                        value: "❌ Jira did not create the issue: {{local.components.create-issue-1.returnValues.error}}\nJira said: {{local.components.create-issue-1.returnValues.response-body}}",
+                    },
+                },
+            ],
+            edges: [
+                {
+                    fromComponentId: trigger,
+                    toComponentId: "prepare-issue-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "prepare-issue-1",
+                    toComponentId: "if-create-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "prepare-issue-1",
+                    toComponentId: "log-prepare-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "if-create-1",
+                    toComponentId: "create-issue-1",
+                    fromPort: "yes",
+                },
+                {
+                    fromComponentId: "if-create-1",
+                    toComponentId: "log-skipped",
+                    fromPort: "no",
+                },
+                {
+                    fromComponentId: "create-issue-1",
+                    toComponentId: "log-created",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "create-issue-1",
+                    toComponentId: "log-create-failed",
+                    fromPort: "error",
+                },
+            ],
+        },
+    };
+};
+const jiraTransitionIssueTemplate = (kind) => {
+    const r = kind.noun;
+    const trigger = `${r}-on-update-1`;
+    return {
+        id: `jira-transition-issue-on-${r}-state`,
+        name: `Move the Jira issue when the ${r} is acknowledged or resolved`,
+        description: `Keeps the linked Jira issue's status in step with the ${r}: acknowledged moves it to In Progress, resolved moves it to Done.`,
+        teaches: "How to look a record up in another system, then choose what to do from what comes back.",
+        category: WorkflowTemplateCategory.Jira,
+        icon: IconProp.Refresh,
+        workflowName: `Sync ${r} state to Jira`,
+        workflowDescription: `Transitions the linked Jira issue when the ${r}'s state changes. Edit the script to map custom states to Jira statuses.`,
+        variables: [JIRA_BASE_URL, JIRA_BASIC_AUTH_TOKEN],
+        graph: {
+            nodes: [
+                {
+                    componentId: trigger,
+                    metadataId: `${r}-on-update`,
+                    componentType: ComponentType.Trigger,
+                    position: { x: 100, y: 100 },
+                    args: {
+                        "listen-on": { [kind.stateIdColumn]: true },
+                        select: {
+                            _id: true,
+                            [kind.numberField]: true,
+                            isPrivate: true,
+                            [kind.stateRelation]: {
+                                name: true,
+                                isAcknowledgedState: true,
+                                isResolvedState: true,
+                            },
+                        },
+                    },
+                },
+                {
+                    componentId: "find-issue-1",
+                    metadataId: ComponentID.ApiPost,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 300 },
+                    args: {
+                        url: "{{local.variables.jiraBaseUrl}}/rest/api/3/search/jql",
+                        "request-headers": jiraHeaders(),
+                        /*
+                         * Asking for the transitions here saves a call: the search
+                         * returns the ones available from the issue's current status.
+                         */
+                        "request-body": jiraSearchBody({
+                            kind: kind,
+                            idReference: `{{local.components.${trigger}.returnValues.model._id}}`,
+                            fields: ["key", "status"],
+                            expandTransitions: true,
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-find-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 600, y: 300 },
+                    args: {
+                        value: `❌ Could not search Jira for the ${r}'s issue: {{local.components.find-issue-1.returnValues.error}}\nJira said: {{local.components.find-issue-1.returnValues.response-body}}`,
+                    },
+                },
+                {
+                    componentId: "plan-transition-1",
+                    metadataId: ComponentID.JavaScriptCode,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 500 },
+                    args: {
+                        code: jiraPlanTransitionScript(kind),
+                        arguments: jsonText({
+                            [r]: `{{local.components.${trigger}.returnValues.model}}`,
+                            search: "{{local.components.find-issue-1.returnValues.response-body}}",
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-plan-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 600, y: 500 },
+                    args: {
+                        value: "❌ Could not choose a Jira transition: {{local.components.plan-transition-1.returnValues.error}}",
+                    },
+                },
+                {
+                    componentId: "if-transition-1",
+                    metadataId: ComponentID.IfElse,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 700 },
+                    args: proceedCondition("plan-transition-1"),
+                },
+                {
+                    componentId: "log-skipped",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 350, y: 900 },
+                    args: {
+                        value: "ℹ️ {{local.components.plan-transition-1.returnValues.returnValue.reason}}",
+                    },
+                },
+                {
+                    componentId: "transition-issue-1",
+                    metadataId: ComponentID.ApiPost,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 900 },
+                    args: {
+                        url: "{{local.variables.jiraBaseUrl}}/rest/api/3/issue/{{local.components.plan-transition-1.returnValues.returnValue.issueKey}}/transitions",
+                        "request-headers": jiraHeaders(),
+                        "request-body": jsonText({
+                            transition: {
+                                id: "{{local.components.plan-transition-1.returnValues.returnValue.transitionId}}",
+                            },
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-transitioned",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 1100 },
+                    args: {
+                        value: "✅ Moved Jira issue {{local.components.plan-transition-1.returnValues.returnValue.issueKey}} to {{local.components.plan-transition-1.returnValues.returnValue.jiraStatus}}. {{local.components.plan-transition-1.returnValues.returnValue.reason}}",
+                    },
+                },
+                {
+                    componentId: "log-transition-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 1100 },
+                    args: {
+                        value: "❌ Jira did not move the issue: {{local.components.transition-issue-1.returnValues.error}}\nJira said: {{local.components.transition-issue-1.returnValues.response-body}}",
+                    },
+                },
+            ],
+            edges: [
+                {
+                    fromComponentId: trigger,
+                    toComponentId: "find-issue-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "find-issue-1",
+                    toComponentId: "plan-transition-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "find-issue-1",
+                    toComponentId: "log-find-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "plan-transition-1",
+                    toComponentId: "if-transition-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "plan-transition-1",
+                    toComponentId: "log-plan-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "if-transition-1",
+                    toComponentId: "transition-issue-1",
+                    fromPort: "yes",
+                },
+                {
+                    fromComponentId: "if-transition-1",
+                    toComponentId: "log-skipped",
+                    fromPort: "no",
+                },
+                {
+                    fromComponentId: "transition-issue-1",
+                    toComponentId: "log-transitioned",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "transition-issue-1",
+                    toComponentId: "log-transition-failed",
+                    fromPort: "error",
+                },
+            ],
+        },
+    };
+};
+/*
+ * Private and public notes go to Jira the same way; only the trigger, the
+ * wording and the comment's visibility differ.
+ */
+const jiraNoteToCommentTemplate = (props) => {
+    const kind = props.kind;
+    const r = kind.noun;
+    const noteKind = `${props.visibility} note`;
+    const commentBody = {
+        body: adfDocument([
+            adfParagraph("{{local.components.build-comment-1.returnValues.returnValue.comment}}"),
+        ]),
+    };
+    if (props.commentProperties) {
+        commentBody["properties"] = props.commentProperties;
+    }
+    return {
+        id: `jira-comment-from-${r}-${props.visibility}-note`,
+        name: `Copy ${r} ${props.visibility} notes to the Jira issue`,
+        description: props.description,
+        teaches: "How to find a record in another system by a label, and how a marker in the text stops two systems echoing each other.",
+        category: WorkflowTemplateCategory.Jira,
+        icon: props.icon,
+        workflowName: `Copy ${r} ${props.visibility} notes to Jira`,
+        workflowDescription: props.workflowDescription,
+        variables: [JIRA_BASE_URL, JIRA_BASIC_AUTH_TOKEN],
+        graph: {
+            nodes: [
+                {
+                    componentId: "note-on-create-1",
+                    metadataId: props.triggerMetadataId,
+                    componentType: ComponentType.Trigger,
+                    position: { x: 100, y: 100 },
+                    args: {
+                        select: {
+                            _id: true,
+                            note: true,
+                            [kind.idColumn]: true,
+                            [r]: { [kind.numberField]: true, isPrivate: true },
+                            createdByUser: { name: true },
+                        },
+                    },
+                },
+                {
+                    componentId: "find-issue-1",
+                    metadataId: ComponentID.ApiPost,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 300 },
+                    args: {
+                        url: "{{local.variables.jiraBaseUrl}}/rest/api/3/search/jql",
+                        "request-headers": jiraHeaders(),
+                        "request-body": jiraSearchBody({
+                            kind: kind,
+                            idReference: `{{local.components.note-on-create-1.returnValues.model.${kind.idColumn}.value}}`,
+                            fields: ["key", "summary"],
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-find-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 600, y: 300 },
+                    args: {
+                        value: `❌ Could not search Jira for the ${r}'s issue: {{local.components.find-issue-1.returnValues.error}}\nJira said: {{local.components.find-issue-1.returnValues.response-body}}`,
+                    },
+                },
+                {
+                    componentId: "build-comment-1",
+                    metadataId: ComponentID.JavaScriptCode,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 500 },
+                    args: {
+                        code: jiraNoteCommentScript(kind, noteKind),
+                        arguments: jsonText({
+                            note: "{{local.components.note-on-create-1.returnValues.model}}",
+                            search: "{{local.components.find-issue-1.returnValues.response-body}}",
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-build-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 600, y: 500 },
+                    args: {
+                        value: "❌ Could not write the Jira comment: {{local.components.build-comment-1.returnValues.error}}",
+                    },
+                },
+                {
+                    componentId: "if-post-1",
+                    metadataId: ComponentID.IfElse,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 700 },
+                    args: proceedCondition("build-comment-1"),
+                },
+                {
+                    componentId: "log-skipped",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 350, y: 900 },
+                    args: {
+                        value: "ℹ️ {{local.components.build-comment-1.returnValues.returnValue.reason}}",
+                    },
+                },
+                {
+                    componentId: "post-comment-1",
+                    metadataId: ComponentID.ApiPost,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 900 },
+                    args: {
+                        url: "{{local.variables.jiraBaseUrl}}/rest/api/3/issue/{{local.components.build-comment-1.returnValues.returnValue.issueKey}}/comment",
+                        "request-headers": jiraHeaders(),
+                        "request-body": jsonText(commentBody),
+                    },
+                },
+                {
+                    componentId: "log-posted",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 1100 },
+                    args: {
+                        value: "✅ Posted the note to Jira issue {{local.components.build-comment-1.returnValues.returnValue.issueKey}}.",
+                    },
+                },
+                {
+                    componentId: "log-post-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 1100 },
+                    args: {
+                        value: "❌ Jira did not accept the comment: {{local.components.post-comment-1.returnValues.error}}\nJira said: {{local.components.post-comment-1.returnValues.response-body}}",
+                    },
+                },
+            ],
+            edges: [
+                {
+                    fromComponentId: "note-on-create-1",
+                    toComponentId: "find-issue-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "find-issue-1",
+                    toComponentId: "build-comment-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "find-issue-1",
+                    toComponentId: "log-find-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "build-comment-1",
+                    toComponentId: "if-post-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "build-comment-1",
+                    toComponentId: "log-build-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "if-post-1",
+                    toComponentId: "post-comment-1",
+                    fromPort: "yes",
+                },
+                {
+                    fromComponentId: "if-post-1",
+                    toComponentId: "log-skipped",
+                    fromPort: "no",
+                },
+                {
+                    fromComponentId: "post-comment-1",
+                    toComponentId: "log-posted",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "post-comment-1",
+                    toComponentId: "log-post-failed",
+                    fromPort: "error",
+                },
+            ],
+        },
+    };
+};
+const jiraPrivateNoteToCommentTemplate = (kind) => {
+    return jiraNoteToCommentTemplate({
+        kind: kind,
+        visibility: "private",
+        description: `Posts every new private note on an ${kind.noun} as a comment on its Jira issue — an internal one in Jira Service Management.`,
+        icon: IconProp.ChatBubbleLeftRight,
+        workflowDescription: `Posts each new private note as a comment on the ${kind.noun}'s linked Jira issue. Notes that came from Jira are not sent back.`,
+        triggerMetadataId: `${kind.noun}-internal-note-on-create`,
+        // A private note stays private in Jira Service Management too.
+        commentProperties: [JIRA_INTERNAL_COMMENT_PROPERTY],
+    });
+};
+const jiraPublicNoteToCommentTemplate = (kind) => {
+    return jiraNoteToCommentTemplate({
+        kind: kind,
+        visibility: "public",
+        description: `Posts every new public note on an ${kind.noun} as a comment on its Jira issue, so the ticket carries the same updates as the status page.`,
+        icon: IconProp.ChatBubbleLeft,
+        workflowDescription: `Posts each new public note as a comment on the ${kind.noun}'s linked Jira issue.`,
+        triggerMetadataId: `${kind.noun}-public-note-on-create`,
+    });
+};
+const jiraUpdateCommentTemplate = (kind) => {
+    const r = kind.noun;
+    const trigger = `${r}-on-update-1`;
+    return {
+        id: `jira-comment-on-${r}-update`,
+        name: `Comment on the Jira issue when the ${r} is edited`,
+        description: `Posts a comment on the linked Jira issue when the ${r}'s ${kind.editedFieldsText} are edited.`,
+        teaches: "How Listen On picks the edits that matter, and how to turn a record into a readable summary.",
+        category: WorkflowTemplateCategory.Jira,
+        icon: IconProp.PencilSquare,
+        workflowName: `Comment on Jira when ${r} changes`,
+        workflowDescription: `When the ${r}'s ${kind.editedFieldsText} are edited, posts how the ${r} now stands to its linked Jira issue. Saving the ${r}'s details form counts, even when it only changed labels or the Private setting. State changes are left to the transition template.`,
+        variables: [JIRA_BASE_URL, JIRA_BASIC_AUTH_TOKEN],
+        graph: {
+            nodes: [
+                {
+                    componentId: trigger,
+                    metadataId: `${r}-on-update`,
+                    componentType: ComponentType.Trigger,
+                    position: { x: 100, y: 100 },
+                    args: {
+                        /*
+                         * State changes are left out on purpose: the transition
+                         * template handles those, and a comment for each would
+                         * double up.
+                         */
+                        "listen-on": kind.editListenOn,
+                        select: {
+                            _id: true,
+                            title: true,
+                            description: true,
+                            [kind.numberField]: true,
+                            isPrivate: true,
+                            rootCause: true,
+                            remediationNotes: true,
+                            [kind.severityRelation]: { name: true },
+                            [kind.stateRelation]: { name: true },
+                        },
+                    },
+                },
+                {
+                    componentId: "find-issue-1",
+                    metadataId: ComponentID.ApiPost,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 300 },
+                    args: {
+                        url: "{{local.variables.jiraBaseUrl}}/rest/api/3/search/jql",
+                        "request-headers": jiraHeaders(),
+                        "request-body": jiraSearchBody({
+                            kind: kind,
+                            idReference: `{{local.components.${trigger}.returnValues.model._id}}`,
+                            fields: ["key", "summary"],
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-find-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 600, y: 300 },
+                    args: {
+                        value: `❌ Could not search Jira for the ${r}'s issue: {{local.components.find-issue-1.returnValues.error}}\nJira said: {{local.components.find-issue-1.returnValues.response-body}}`,
+                    },
+                },
+                {
+                    componentId: "build-comment-1",
+                    metadataId: ComponentID.JavaScriptCode,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 500 },
+                    args: {
+                        code: jiraUpdateCommentScript(kind),
+                        arguments: jsonText({
+                            [r]: `{{local.components.${trigger}.returnValues.model}}`,
+                            search: "{{local.components.find-issue-1.returnValues.response-body}}",
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-build-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 600, y: 500 },
+                    args: {
+                        value: "❌ Could not write the Jira comment: {{local.components.build-comment-1.returnValues.error}}",
+                    },
+                },
+                {
+                    componentId: "if-post-1",
+                    metadataId: ComponentID.IfElse,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 700 },
+                    args: proceedCondition("build-comment-1"),
+                },
+                {
+                    componentId: "log-skipped",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 350, y: 900 },
+                    args: {
+                        value: "ℹ️ {{local.components.build-comment-1.returnValues.returnValue.reason}}",
+                    },
+                },
+                {
+                    componentId: "post-comment-1",
+                    metadataId: ComponentID.ApiPost,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 900 },
+                    args: {
+                        url: "{{local.variables.jiraBaseUrl}}/rest/api/3/issue/{{local.components.build-comment-1.returnValues.returnValue.issueKey}}/comment",
+                        "request-headers": jiraHeaders(),
+                        "request-body": jsonText({
+                            body: adfDocument([
+                                adfParagraph("{{local.components.build-comment-1.returnValues.returnValue.comment}}"),
+                            ]),
+                            // Root causes and remediation are for the team, not the customer.
+                            properties: [JIRA_INTERNAL_COMMENT_PROPERTY],
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-posted",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 1100 },
+                    args: {
+                        value: `✅ Posted the ${r}'s changes to Jira issue {{local.components.build-comment-1.returnValues.returnValue.issueKey}}.`,
+                    },
+                },
+                {
+                    componentId: "log-post-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 1100 },
+                    args: {
+                        value: "❌ Jira did not accept the comment: {{local.components.post-comment-1.returnValues.error}}\nJira said: {{local.components.post-comment-1.returnValues.response-body}}",
+                    },
+                },
+            ],
+            edges: [
+                {
+                    fromComponentId: trigger,
+                    toComponentId: "find-issue-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "find-issue-1",
+                    toComponentId: "build-comment-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "find-issue-1",
+                    toComponentId: "log-find-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "build-comment-1",
+                    toComponentId: "if-post-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "build-comment-1",
+                    toComponentId: "log-build-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "if-post-1",
+                    toComponentId: "post-comment-1",
+                    fromPort: "yes",
+                },
+                {
+                    fromComponentId: "if-post-1",
+                    toComponentId: "log-skipped",
+                    fromPort: "no",
+                },
+                {
+                    fromComponentId: "post-comment-1",
+                    toComponentId: "log-posted",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "post-comment-1",
+                    toComponentId: "log-post-failed",
+                    fromPort: "error",
+                },
+            ],
+        },
+    };
+};
+/* ----------------------- Jira -> OneUptime ----------------------- */
+const jiraCreateRecordTemplate = (kind) => {
+    const r = kind.noun;
+    const prepare = `prepare-${r}-1`;
+    const create = `create-${r}-1`;
+    const createJson = Object.assign(Object.assign({ [kind.severityIdColumn]: `{{local.components.${prepare}.returnValues.returnValue.${kind.severityIdColumn}}}`, customFields: {
+            jiraIssueKey: `{{local.components.${prepare}.returnValues.returnValue.issueKey}}`,
+        } }, kind.quietCreateFields), { title: `{{local.components.${prepare}.returnValues.returnValue.title}}`, description: `{{local.components.${prepare}.returnValues.returnValue.description}}` });
+    return {
+        id: `jira-${kind.create}-${r}-from-issue`,
+        name: `${kind.Create} an ${r} when a Jira issue is created`,
+        description: `Point a Jira webhook at this workflow and each new issue becomes an ${r}, with its severity chosen from the issue's priority.`,
+        teaches: "How to receive another system's webhook, map its fields, and write back to it once you have an id.",
+        category: WorkflowTemplateCategory.Jira,
+        icon: IconProp.Bug,
+        workflowName: `${kind.Create} ${r} from Jira issue`,
+        workflowDescription: `${kind.Create}s an ${r}${kind.quietCreateText} for each Jira issue created. Enable it, copy the URL from the Webhook trigger, and register it in Jira under Settings > System > WebHooks for the Issue created event. If you also create ${kind.otherPlural} from Jira, give the two webhooks JQL filters that never match the same issue, or each issue becomes both.`,
+        variables: [JIRA_BASE_URL, JIRA_BASIC_AUTH_TOKEN],
+        graph: {
+            nodes: [
+                {
+                    componentId: "webhook-1",
+                    metadataId: ComponentID.Webhook,
+                    componentType: ComponentType.Trigger,
+                    position: { x: 100, y: 100 },
+                },
+                {
+                    componentId: "find-severities-1",
+                    metadataId: `${r}-severity-find-many`,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 300 },
+                    args: {
+                        // Every row. Query cannot be left empty, so it asks for any id.
+                        query: { _id: { _type: "NotNull", value: null } },
+                        select: { _id: true, name: true, order: true },
+                        limit: 50,
+                    },
+                },
+                {
+                    componentId: "log-severities-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 600, y: 300 },
+                    args: {
+                        value: `❌ Could not read this project's ${r} severities. The database error is in the run log above.`,
+                    },
+                },
+                {
+                    componentId: prepare,
+                    metadataId: ComponentID.JavaScriptCode,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 500 },
+                    args: {
+                        code: jiraPrepareRecordScript(kind),
+                        /*
+                         * The Jira payload goes last. Text Jira users wrote is only
+                         * ever substituted after everything else in an argument.
+                         */
+                        arguments: jsonText({
+                            severities: "{{local.components.find-severities-1.returnValues.models}}",
+                            payload: "{{local.components.webhook-1.returnValues.request-body}}",
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-prepare-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 600, y: 500 },
+                    args: {
+                        value: `❌ Could not read the Jira event: {{local.components.${prepare}.returnValues.error}}`,
+                    },
+                },
+                {
+                    componentId: `if-${kind.create}-1`,
+                    metadataId: ComponentID.IfElse,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 700 },
+                    args: proceedCondition(prepare),
+                },
+                {
+                    componentId: "log-skipped",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 350, y: 900 },
+                    args: {
+                        value: `ℹ️ {{local.components.${prepare}.returnValues.returnValue.reason}}`,
+                    },
+                },
+                {
+                    /*
+                     * The webhook's word is not taken for whether the issue is already
+                     * linked. Anyone holding this workflow's URL can describe any issue,
+                     * and a delivery Jira retries arrives after the first one labelled
+                     * the issue — so ask Jira what the labels are now.
+                     */
+                    componentId: "get-issue-1",
+                    metadataId: ComponentID.ApiGet,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 900 },
+                    args: {
+                        url: `{{local.variables.jiraBaseUrl}}/rest/api/3/issue/{{local.components.${prepare}.returnValues.returnValue.issueKey}}?fields=labels`,
+                        "request-headers": jiraHeaders(),
+                    },
+                },
+                {
+                    componentId: "log-get-issue-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 1100 },
+                    args: {
+                        value: `❌ Could not read Jira issue {{local.components.${prepare}.returnValues.returnValue.issueKey}}, so no ${r} was ${kind.created}: {{local.components.get-issue-1.returnValues.error}}\nJira said: {{local.components.get-issue-1.returnValues.response-body}}`,
+                    },
+                },
+                {
+                    componentId: "confirm-unlinked-1",
+                    metadataId: ComponentID.JavaScriptCode,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 1100 },
+                    args: {
+                        code: jiraConfirmUnlinkedScript(kind),
+                        arguments: jsonText({
+                            issue: "{{local.components.get-issue-1.returnValues.response-body}}",
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-confirm-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 1300 },
+                    args: {
+                        value: "❌ Could not read the issue's labels: {{local.components.confirm-unlinked-1.returnValues.error}}",
+                    },
+                },
+                {
+                    componentId: "if-unlinked-1",
+                    metadataId: ComponentID.IfElse,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 1300 },
+                    args: proceedCondition("confirm-unlinked-1"),
+                },
+                {
+                    componentId: "log-already-linked",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 1500 },
+                    args: {
+                        value: "ℹ️ {{local.components.confirm-unlinked-1.returnValues.returnValue.reason}}",
+                    },
+                },
+                {
+                    componentId: create,
+                    metadataId: `${r}-create-one`,
+                    componentType: ComponentType.Component,
+                    position: { x: -400, y: 1500 },
+                    args: {
+                        /*
+                         * customFields.jiraIssueKey is what stops the create-issue
+                         * template filing this record back into Jira as a second issue.
+                         */
+                        json: jsonText(createJson),
+                    },
+                },
+                {
+                    componentId: "log-create-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 1700 },
+                    args: {
+                        value: `❌ Could not ${kind.create} the ${r} for Jira issue {{local.components.${prepare}.returnValues.returnValue.issueKey}}. The database error is in the run log above.`,
+                    },
+                },
+                {
+                    componentId: "link-issue-1",
+                    metadataId: ComponentID.ApiPut,
+                    componentType: ComponentType.Component,
+                    position: { x: -400, y: 1700 },
+                    args: {
+                        url: `{{local.variables.jiraBaseUrl}}/rest/api/3/issue/{{local.components.${prepare}.returnValues.returnValue.issueKey}}`,
+                        "request-headers": jiraHeaders(),
+                        "request-body": jsonText({
+                            update: {
+                                labels: [
+                                    { add: JIRA_LINK_LABEL },
+                                    {
+                                        add: `${kind.labelPrefix}{{local.components.${create}.returnValues.model._id}}`,
+                                    },
+                                ],
+                            },
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-linked",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -400, y: 1900 },
+                    args: {
+                        value: `✅ ${kind.Created} an ${r} with severity {{local.components.${prepare}.returnValues.returnValue.severityName}} for Jira issue {{local.components.${prepare}.returnValues.returnValue.issueKey}}, and labelled the issue to link them.`,
+                    },
+                },
+                {
+                    componentId: "log-link-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 1900 },
+                    args: {
+                        value: `⚠️ The ${r} was ${kind.created}, but Jira did not accept the link labels, so the other Jira templates cannot find it: {{local.components.link-issue-1.returnValues.error}}\nJira said: {{local.components.link-issue-1.returnValues.response-body}}`,
+                    },
+                },
+            ],
+            edges: [
+                {
+                    fromComponentId: "webhook-1",
+                    toComponentId: "find-severities-1",
+                    fromPort: "out",
+                },
+                {
+                    fromComponentId: "find-severities-1",
+                    toComponentId: prepare,
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "find-severities-1",
+                    toComponentId: "log-severities-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: prepare,
+                    toComponentId: `if-${kind.create}-1`,
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: prepare,
+                    toComponentId: "log-prepare-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: `if-${kind.create}-1`,
+                    toComponentId: "get-issue-1",
+                    fromPort: "yes",
+                },
+                {
+                    fromComponentId: "get-issue-1",
+                    toComponentId: "confirm-unlinked-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "get-issue-1",
+                    toComponentId: "log-get-issue-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "confirm-unlinked-1",
+                    toComponentId: "if-unlinked-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "confirm-unlinked-1",
+                    toComponentId: "log-confirm-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "if-unlinked-1",
+                    toComponentId: create,
+                    fromPort: "yes",
+                },
+                {
+                    fromComponentId: "if-unlinked-1",
+                    toComponentId: "log-already-linked",
+                    fromPort: "no",
+                },
+                {
+                    fromComponentId: `if-${kind.create}-1`,
+                    toComponentId: "log-skipped",
+                    fromPort: "no",
+                },
+                {
+                    fromComponentId: create,
+                    toComponentId: "link-issue-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: create,
+                    toComponentId: "log-create-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "link-issue-1",
+                    toComponentId: "log-linked",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "link-issue-1",
+                    toComponentId: "log-link-failed",
+                    fromPort: "error",
+                },
+            ],
+        },
+    };
+};
+const jiraStatusToStateTemplate = (kind) => {
+    const r = kind.noun;
+    const find = `find-${r}-1`;
+    return {
+        id: `jira-status-to-${r}-state`,
+        name: `Acknowledge or resolve the ${r} when its Jira issue moves`,
+        description: `When the linked Jira issue moves to In Progress the ${r} is acknowledged, and when it moves to Done the ${r} is resolved.`,
+        teaches: `How to read a Jira changelog, and why an ${r}'s state only ever moves forward.`,
+        category: WorkflowTemplateCategory.Jira,
+        icon: IconProp.ClipboardDocumentCheck,
+        workflowName: `Sync Jira status to ${r}`,
+        workflowDescription: `Changes the ${r}'s state when its linked Jira issue changes status. Enable it, copy the URL from the Webhook trigger, and register it in Jira under Settings > System > WebHooks for the Issue updated event.`,
+        variables: [],
+        graph: {
+            nodes: [
+                {
+                    componentId: "webhook-1",
+                    metadataId: ComponentID.Webhook,
+                    componentType: ComponentType.Trigger,
+                    position: { x: 100, y: 100 },
+                },
+                {
+                    componentId: "read-event-1",
+                    metadataId: ComponentID.JavaScriptCode,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 300 },
+                    args: {
+                        code: jiraReadStatusChangeScript(kind),
+                        arguments: "{{local.components.webhook-1.returnValues.request-body}}",
+                    },
+                },
+                {
+                    componentId: "log-read-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 600, y: 300 },
+                    args: {
+                        value: "❌ Could not read the Jira event: {{local.components.read-event-1.returnValues.error}}",
+                    },
+                },
+                {
+                    componentId: "if-status-changed-1",
+                    metadataId: ComponentID.IfElse,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 500 },
+                    args: proceedCondition("read-event-1"),
+                },
+                {
+                    componentId: "log-ignored",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 350, y: 700 },
+                    args: {
+                        value: "ℹ️ {{local.components.read-event-1.returnValues.returnValue.reason}}",
+                    },
+                },
+                {
+                    componentId: find,
+                    metadataId: `${r}-find-one`,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 700 },
+                    args: {
+                        query: {
+                            _id: `{{local.components.read-event-1.returnValues.returnValue.${r}Id}}`,
+                        },
+                        select: {
+                            _id: true,
+                            [kind.numberField]: true,
+                            [kind.stateRelation]: { _id: true, name: true, order: true },
+                        },
+                    },
+                },
+                {
+                    componentId: `log-find-${r}-failed`,
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 900 },
+                    args: {
+                        value: `❌ Could not look up the ${r}. The database error is in the run log above.`,
+                    },
+                },
+                {
+                    componentId: "find-states-1",
+                    metadataId: `${r}-state-find-many`,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 900 },
+                    args: {
+                        // Every row. Query cannot be left empty, so it asks for any id.
+                        query: { _id: { _type: "NotNull", value: null } },
+                        select: {
+                            _id: true,
+                            name: true,
+                            order: true,
+                            isAcknowledgedState: true,
+                            isResolvedState: true,
+                        },
+                        limit: 50,
+                    },
+                },
+                {
+                    componentId: "log-find-states-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 1100 },
+                    args: {
+                        value: `❌ Could not read this project's ${r} states. The database error is in the run log above.`,
+                    },
+                },
+                {
+                    componentId: "decide-state-1",
+                    metadataId: ComponentID.JavaScriptCode,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 1100 },
+                    args: {
+                        code: jiraDecideStateScript(kind),
+                        /*
+                         * The event goes last: its status and user names are Jira users'
+                         * text, and text from the other system is only ever substituted
+                         * after everything else in an argument.
+                         */
+                        arguments: jsonText({
+                            [r]: `{{local.components.${find}.returnValues.model}}`,
+                            states: "{{local.components.find-states-1.returnValues.models}}",
+                            event: "{{local.components.read-event-1.returnValues.returnValue}}",
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-decide-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 1300 },
+                    args: {
+                        value: `❌ Could not map the Jira status to an ${r} state: {{local.components.decide-state-1.returnValues.error}}`,
+                    },
+                },
+                {
+                    componentId: "if-change-1",
+                    metadataId: ComponentID.IfElse,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 1300 },
+                    args: proceedCondition("decide-state-1"),
+                },
+                {
+                    componentId: "log-unchanged",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 1500 },
+                    args: {
+                        value: "ℹ️ {{local.components.decide-state-1.returnValues.returnValue.reason}}",
+                    },
+                },
+                {
+                    /*
+                     * A state change is a new timeline row, not an edit to the
+                     * record: the timeline is what records it, notifies, and refuses
+                     * to move a record backwards.
+                     */
+                    componentId: "change-state-1",
+                    metadataId: `${r}-state-timeline-create-one`,
+                    componentType: ComponentType.Component,
+                    position: { x: -400, y: 1500 },
+                    args: {
+                        json: jsonText({
+                            [kind.idColumn]: `{{local.components.decide-state-1.returnValues.returnValue.${r}Id}}`,
+                            [kind.timelineStateColumn]: "{{local.components.decide-state-1.returnValues.returnValue.stateId}}",
+                            rootCause: "{{local.components.decide-state-1.returnValues.returnValue.rootCause}}",
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-changed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -400, y: 1700 },
+                    args: {
+                        value: `✅ Moved {{local.components.${find}.returnValues.model.${kind.numberField}}} to {{local.components.decide-state-1.returnValues.returnValue.stateName}} because Jira issue {{local.components.read-event-1.returnValues.returnValue.issueKey}} is now {{local.components.read-event-1.returnValues.returnValue.jiraStatus}}.`,
+                    },
+                },
+                {
+                    componentId: "log-change-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 1700 },
+                    args: {
+                        value: `❌ Could not change the ${r}'s state. The reason is in the run log above — an ${r} cannot move back to an earlier state.`,
+                    },
+                },
+            ],
+            edges: [
+                {
+                    fromComponentId: "webhook-1",
+                    toComponentId: "read-event-1",
+                    fromPort: "out",
+                },
+                {
+                    fromComponentId: "read-event-1",
+                    toComponentId: "if-status-changed-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "read-event-1",
+                    toComponentId: "log-read-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "if-status-changed-1",
+                    toComponentId: find,
+                    fromPort: "yes",
+                },
+                {
+                    fromComponentId: "if-status-changed-1",
+                    toComponentId: "log-ignored",
+                    fromPort: "no",
+                },
+                {
+                    fromComponentId: find,
+                    toComponentId: "find-states-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: find,
+                    toComponentId: `log-find-${r}-failed`,
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "find-states-1",
+                    toComponentId: "decide-state-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "find-states-1",
+                    toComponentId: "log-find-states-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "decide-state-1",
+                    toComponentId: "if-change-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "decide-state-1",
+                    toComponentId: "log-decide-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "if-change-1",
+                    toComponentId: "change-state-1",
+                    fromPort: "yes",
+                },
+                {
+                    fromComponentId: "if-change-1",
+                    toComponentId: "log-unchanged",
+                    fromPort: "no",
+                },
+                {
+                    fromComponentId: "change-state-1",
+                    toComponentId: "log-changed",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "change-state-1",
+                    toComponentId: "log-change-failed",
+                    fromPort: "error",
+                },
+            ],
+        },
+    };
+};
+const jiraCommentToNoteTemplate = (kind) => {
+    const r = kind.noun;
+    const find = `find-${r}-1`;
+    return {
+        id: `jira-comment-to-${r}-private-note`,
+        name: `Add Jira comments to the ${r} as private notes`,
+        description: `Copies each comment on the linked Jira issue onto the ${r} as a private note, so responders see the whole conversation in one place.`,
+        teaches: "How to follow a webhook with a lookup call when the payload does not carry everything you need.",
+        category: WorkflowTemplateCategory.Jira,
+        icon: IconProp.ChatBubbleOvalLeftEllipsis,
+        workflowName: `Copy Jira comments to ${r}`,
+        workflowDescription: `Adds each comment on a linked Jira issue to the ${r} as a private note. Enable it, copy the URL from the Webhook trigger, and register it in Jira under Settings > System > WebHooks for the Comment created event.`,
+        variables: [JIRA_BASE_URL, JIRA_BASIC_AUTH_TOKEN],
+        graph: {
+            nodes: [
+                {
+                    componentId: "webhook-1",
+                    metadataId: ComponentID.Webhook,
+                    componentType: ComponentType.Trigger,
+                    position: { x: 100, y: 100 },
+                },
+                {
+                    componentId: "read-comment-1",
+                    metadataId: ComponentID.JavaScriptCode,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 300 },
+                    args: {
+                        code: jiraReadCommentScript(kind),
+                        arguments: "{{local.components.webhook-1.returnValues.request-body}}",
+                    },
+                },
+                {
+                    componentId: "log-read-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 600, y: 300 },
+                    args: {
+                        value: "❌ Could not read the Jira event: {{local.components.read-comment-1.returnValues.error}}",
+                    },
+                },
+                {
+                    componentId: "if-comment-1",
+                    metadataId: ComponentID.IfElse,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 500 },
+                    args: proceedCondition("read-comment-1"),
+                },
+                {
+                    componentId: "log-ignored",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 350, y: 700 },
+                    args: {
+                        value: "ℹ️ {{local.components.read-comment-1.returnValues.returnValue.reason}}",
+                    },
+                },
+                {
+                    componentId: "get-issue-1",
+                    metadataId: ComponentID.ApiGet,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 700 },
+                    args: {
+                        url: "{{local.variables.jiraBaseUrl}}/rest/api/3/issue/{{local.components.read-comment-1.returnValues.returnValue.issueKey}}?fields=labels",
+                        "request-headers": jiraHeaders(),
+                    },
+                },
+                {
+                    componentId: "log-get-issue-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 900 },
+                    args: {
+                        value: "❌ Could not read Jira issue {{local.components.read-comment-1.returnValues.returnValue.issueKey}}: {{local.components.get-issue-1.returnValues.error}}\nJira said: {{local.components.get-issue-1.returnValues.response-body}}",
+                    },
+                },
+                {
+                    componentId: "find-link-1",
+                    metadataId: ComponentID.JavaScriptCode,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 900 },
+                    args: {
+                        code: jiraFindLinkedRecordScript(kind),
+                        arguments: jsonText({
+                            comment: "{{local.components.read-comment-1.returnValues.returnValue}}",
+                            issue: "{{local.components.get-issue-1.returnValues.response-body}}",
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-find-link-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 1100 },
+                    args: {
+                        value: "❌ Could not read the issue's labels: {{local.components.find-link-1.returnValues.error}}",
+                    },
+                },
+                {
+                    componentId: "if-linked-1",
+                    metadataId: ComponentID.IfElse,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 1100 },
+                    args: proceedCondition("find-link-1"),
+                },
+                {
+                    componentId: "log-not-linked",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 1300 },
+                    args: {
+                        value: "ℹ️ {{local.components.find-link-1.returnValues.returnValue.reason}}",
+                    },
+                },
+                {
+                    componentId: find,
+                    metadataId: `${r}-find-one`,
+                    componentType: ComponentType.Component,
+                    position: { x: -400, y: 1300 },
+                    args: {
+                        query: {
+                            _id: `{{local.components.find-link-1.returnValues.returnValue.${r}Id}}`,
+                        },
+                        select: { _id: true, [kind.numberField]: true },
+                    },
+                },
+                {
+                    componentId: `log-find-${r}-failed`,
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 1500 },
+                    args: {
+                        value: `❌ Could not look up the ${r}. The database error is in the run log above.`,
+                    },
+                },
+                {
+                    /*
+                     * Find One answers "nothing matched" on its Success port, so this
+                     * is what stops a label naming a record in another project — the
+                     * lookup is scoped to this one — from being written to.
+                     */
+                    componentId: "if-found-1",
+                    metadataId: ComponentID.IfElse,
+                    componentType: ComponentType.Component,
+                    position: { x: -400, y: 1500 },
+                    args: {
+                        "input-1-type": ConditionValueType.Text,
+                        "input-1": `{{local.components.${find}.returnValues.model._id}}`,
+                        operator: ConditionOperator.EqualTo,
+                        "input-2-type": ConditionValueType.Text,
+                        "input-2": `{{local.components.find-link-1.returnValues.returnValue.${r}Id}}`,
+                    },
+                },
+                {
+                    componentId: "log-not-found",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 1700 },
+                    args: {
+                        value: `ℹ️ Jira issue {{local.components.read-comment-1.returnValues.returnValue.issueKey}} names ${r} {{local.components.find-link-1.returnValues.returnValue.${r}Id}}, which is not in this project.`,
+                    },
+                },
+                {
+                    componentId: "create-note-1",
+                    metadataId: `${r}-internal-note-create-one`,
+                    componentType: ComponentType.Component,
+                    position: { x: -650, y: 1700 },
+                    args: {
+                        json: jsonText({
+                            [kind.idColumn]: `{{local.components.${find}.returnValues.model._id}}`,
+                            note: "{{local.components.read-comment-1.returnValues.returnValue.note}}",
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-noted",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -650, y: 1900 },
+                    args: {
+                        value: `✅ Added the Jira comment on {{local.components.read-comment-1.returnValues.returnValue.issueKey}} to {{local.components.${find}.returnValues.model.${kind.numberField}}} as a private note.`,
+                    },
+                },
+                {
+                    componentId: "log-note-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -400, y: 1900 },
+                    args: {
+                        value: "❌ Could not add the private note. The database error is in the run log above.",
+                    },
+                },
+            ],
+            edges: [
+                {
+                    fromComponentId: "webhook-1",
+                    toComponentId: "read-comment-1",
+                    fromPort: "out",
+                },
+                {
+                    fromComponentId: "read-comment-1",
+                    toComponentId: "if-comment-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "read-comment-1",
+                    toComponentId: "log-read-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "if-comment-1",
+                    toComponentId: "get-issue-1",
+                    fromPort: "yes",
+                },
+                {
+                    fromComponentId: "if-comment-1",
+                    toComponentId: "log-ignored",
+                    fromPort: "no",
+                },
+                {
+                    fromComponentId: "get-issue-1",
+                    toComponentId: "find-link-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "get-issue-1",
+                    toComponentId: "log-get-issue-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "find-link-1",
+                    toComponentId: "if-linked-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "find-link-1",
+                    toComponentId: "log-find-link-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "if-linked-1",
+                    toComponentId: find,
+                    fromPort: "yes",
+                },
+                {
+                    fromComponentId: "if-linked-1",
+                    toComponentId: "log-not-linked",
+                    fromPort: "no",
+                },
+                {
+                    fromComponentId: find,
+                    toComponentId: "if-found-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: find,
+                    toComponentId: `log-find-${r}-failed`,
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "if-found-1",
+                    toComponentId: "create-note-1",
+                    fromPort: "yes",
+                },
+                {
+                    fromComponentId: "if-found-1",
+                    toComponentId: "log-not-found",
+                    fromPort: "no",
+                },
+                {
+                    fromComponentId: "create-note-1",
+                    toComponentId: "log-noted",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "create-note-1",
+                    toComponentId: "log-note-failed",
+                    fromPort: "error",
+                },
+            ],
+        },
+    };
+};
+const jiraIssueChangesToNoteTemplate = (kind) => {
+    const r = kind.noun;
+    const find = `find-${r}-1`;
+    return {
+        id: `jira-issue-changes-to-${r}-private-note`,
+        name: `Add Jira issue changes to the ${r} as private notes`,
+        description: `When someone edits the linked Jira issue — its priority, assignee, summary and so on — the change is noted on the ${r}.`,
+        teaches: "How to turn a list of changes in a webhook into one readable note.",
+        category: WorkflowTemplateCategory.Jira,
+        icon: IconProp.DocumentText,
+        workflowName: `Copy Jira issue changes to ${r}`,
+        workflowDescription: `Notes each change to a linked Jira issue on the ${r} as a private note. Enable it, copy the URL from the Webhook trigger, and register it in Jira under Settings > System > WebHooks for the Issue updated event.`,
+        variables: [],
+        graph: {
+            nodes: [
+                {
+                    componentId: "webhook-1",
+                    metadataId: ComponentID.Webhook,
+                    componentType: ComponentType.Trigger,
+                    position: { x: 100, y: 100 },
+                },
+                {
+                    componentId: "read-changes-1",
+                    metadataId: ComponentID.JavaScriptCode,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 300 },
+                    args: {
+                        code: jiraReadIssueChangesScript(kind),
+                        arguments: "{{local.components.webhook-1.returnValues.request-body}}",
+                    },
+                },
+                {
+                    componentId: "log-read-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 600, y: 300 },
+                    args: {
+                        value: "❌ Could not read the Jira event: {{local.components.read-changes-1.returnValues.error}}",
+                    },
+                },
+                {
+                    componentId: "if-changed-1",
+                    metadataId: ComponentID.IfElse,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 500 },
+                    args: proceedCondition("read-changes-1"),
+                },
+                {
+                    componentId: "log-ignored",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 350, y: 700 },
+                    args: {
+                        value: "ℹ️ {{local.components.read-changes-1.returnValues.returnValue.reason}}",
+                    },
+                },
+                {
+                    componentId: find,
+                    metadataId: `${r}-find-one`,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 700 },
+                    args: {
+                        query: {
+                            _id: `{{local.components.read-changes-1.returnValues.returnValue.${r}Id}}`,
+                        },
+                        select: { _id: true, [kind.numberField]: true },
+                    },
+                },
+                {
+                    componentId: `log-find-${r}-failed`,
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 900 },
+                    args: {
+                        value: `❌ Could not look up the ${r}. The database error is in the run log above.`,
+                    },
+                },
+                {
+                    componentId: "if-found-1",
+                    metadataId: ComponentID.IfElse,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 900 },
+                    args: {
+                        "input-1-type": ConditionValueType.Text,
+                        "input-1": `{{local.components.${find}.returnValues.model._id}}`,
+                        operator: ConditionOperator.EqualTo,
+                        "input-2-type": ConditionValueType.Text,
+                        "input-2": `{{local.components.read-changes-1.returnValues.returnValue.${r}Id}}`,
+                    },
+                },
+                {
+                    componentId: "log-not-found",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: 100, y: 1100 },
+                    args: {
+                        value: `ℹ️ Jira issue {{local.components.read-changes-1.returnValues.returnValue.issueKey}} names ${r} {{local.components.read-changes-1.returnValues.returnValue.${r}Id}}, which is not in this project.`,
+                    },
+                },
+                {
+                    componentId: "create-note-1",
+                    metadataId: `${r}-internal-note-create-one`,
+                    componentType: ComponentType.Component,
+                    position: { x: -400, y: 1100 },
+                    args: {
+                        json: jsonText({
+                            [kind.idColumn]: `{{local.components.${find}.returnValues.model._id}}`,
+                            note: "{{local.components.read-changes-1.returnValues.returnValue.note}}",
+                        }),
+                    },
+                },
+                {
+                    componentId: "log-noted",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -400, y: 1300 },
+                    args: {
+                        value: `✅ Noted the changes to Jira issue {{local.components.read-changes-1.returnValues.returnValue.issueKey}} on {{local.components.${find}.returnValues.model.${kind.numberField}}}.`,
+                    },
+                },
+                {
+                    componentId: "log-note-failed",
+                    metadataId: ComponentID.Log,
+                    componentType: ComponentType.Component,
+                    position: { x: -150, y: 1300 },
+                    args: {
+                        value: "❌ Could not add the private note. The database error is in the run log above.",
+                    },
+                },
+            ],
+            edges: [
+                {
+                    fromComponentId: "webhook-1",
+                    toComponentId: "read-changes-1",
+                    fromPort: "out",
+                },
+                {
+                    fromComponentId: "read-changes-1",
+                    toComponentId: "if-changed-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "read-changes-1",
+                    toComponentId: "log-read-failed",
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "if-changed-1",
+                    toComponentId: find,
+                    fromPort: "yes",
+                },
+                {
+                    fromComponentId: "if-changed-1",
+                    toComponentId: "log-ignored",
+                    fromPort: "no",
+                },
+                {
+                    fromComponentId: find,
+                    toComponentId: "if-found-1",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: find,
+                    toComponentId: `log-find-${r}-failed`,
+                    fromPort: "error",
+                },
+                {
+                    fromComponentId: "if-found-1",
+                    toComponentId: "create-note-1",
+                    fromPort: "yes",
+                },
+                {
+                    fromComponentId: "if-found-1",
+                    toComponentId: "log-not-found",
+                    fromPort: "no",
+                },
+                {
+                    fromComponentId: "create-note-1",
+                    toComponentId: "log-noted",
+                    fromPort: "success",
+                },
+                {
+                    fromComponentId: "create-note-1",
+                    toComponentId: "log-note-failed",
+                    fromPort: "error",
+                },
+            ],
+        },
+    };
+};
+/** One kind's set, OneUptime -> Jira first. Public notes exist only on incidents. */
+const jiraTemplatesForKind = (kind) => {
+    return [
+        jiraCreateIssueTemplate(kind),
+        jiraTransitionIssueTemplate(kind),
+        jiraPrivateNoteToCommentTemplate(kind),
+        ...(kind.hasPublicNotes ? [jiraPublicNoteToCommentTemplate(kind)] : []),
+        jiraUpdateCommentTemplate(kind),
+        jiraCreateRecordTemplate(kind),
+        jiraStatusToStateTemplate(kind),
+        jiraCommentToNoteTemplate(kind),
+        jiraIssueChangesToNoteTemplate(kind),
+    ];
+};
+const JIRA_TEMPLATE_DEFINITIONS = [
+    ...jiraTemplatesForKind(INCIDENT_KIND),
+    ...jiraTemplatesForKind(ALERT_KIND),
+];
 const TEMPLATE_DEFINITIONS = [
     /* ----------------------------- Basics ----------------------------- */
     {
@@ -657,7 +3347,7 @@ const TEMPLATE_DEFINITIONS = [
                         url: "{{local.variables.forwardUrl}}",
                         "request-body": [
                             "{",
-                            '  "id": "{{local.components.incident-on-create-1.returnValues.model._id.value}}",',
+                            '  "id": "{{local.components.incident-on-create-1.returnValues.model._id}}",',
                             '  "number": "{{local.components.incident-on-create-1.returnValues.model.incidentNumber}}",',
                             '  "title": "{{local.components.incident-on-create-1.returnValues.model.title}}",',
                             '  "severity": "{{local.components.incident-on-create-1.returnValues.model.incidentSeverity.name}}",',
@@ -1097,7 +3787,7 @@ const TEMPLATE_DEFINITIONS = [
                         url: "{{local.variables.forwardUrl}}",
                         "request-body": [
                             "{",
-                            '  "eventId": "{{local.components.monitor-status-timeline-on-create-1.returnValues.model._id.value}}",',
+                            '  "eventId": "{{local.components.monitor-status-timeline-on-create-1.returnValues.model._id}}",',
                             '  "monitor": "{{local.components.monitor-status-timeline-on-create-1.returnValues.model.monitor.name}}",',
                             '  "status": "{{local.components.monitor-status-timeline-on-create-1.returnValues.model.monitorStatus.name}}",',
                             '  "isOffline": {{local.components.monitor-status-timeline-on-create-1.returnValues.model.monitorStatus.isOfflineState}}',
@@ -1900,6 +4590,8 @@ const TEMPLATE_DEFINITIONS = [
             ],
         },
     },
+    /* ------------------------------- Jira ------------------------------- */
+    ...JIRA_TEMPLATE_DEFINITIONS,
     /* --------------------------- Integrations --------------------------- */
     {
         id: "webhook-to-slack",