@bpmnkit/core 1.3.0 → 1.4.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/bpmn/compact.d.ts +6 -0
- package/dist/bpmn/compact.js +14 -0
- package/dist/bpmn/full-operations.js +8 -1
- package/dist/bpmn/process-delta.d.ts +4 -0
- package/dist/bpmn/process-delta.js +11 -2
- package/dist/bpmn/process-text-writer.js +6 -0
- package/dist/bpmn/process-text.d.ts +11 -1
- package/dist/bpmn/process-text.js +85 -3
- package/package.json +1 -1
package/dist/bpmn/compact.d.ts
CHANGED
|
@@ -39,9 +39,15 @@ export interface CompactElement {
|
|
|
39
39
|
formId?: string;
|
|
40
40
|
/** Linked decision ID (businessRuleTask: zeebe:calledDecision.decisionId) */
|
|
41
41
|
decisionId?: string;
|
|
42
|
+
/**
|
|
43
|
+
* The FEEL expression a script task evaluates (`zeebe:script`), with its leading
|
|
44
|
+
* `=`. Its value goes to {@link resultVariable}.
|
|
45
|
+
*/
|
|
46
|
+
script?: string;
|
|
42
47
|
/**
|
|
43
48
|
* Primary output variable.
|
|
44
49
|
* - For businessRuleTask: stored in zeebe:calledDecision.resultVariable.
|
|
50
|
+
* - For a scriptTask with {@link script}: stored in zeebe:script.resultVariable.
|
|
45
51
|
* - For a Camunda connector job type (`io.camunda:…`): stored as the `resultVariable`
|
|
46
52
|
* task header, which is where the connector runtime reads it.
|
|
47
53
|
* - For any other serviceTask with jobType: stored as a zeebe:ioMapping output (source "= response").
|
package/dist/bpmn/compact.js
CHANGED
|
@@ -77,12 +77,19 @@ function compactifyElement(el) {
|
|
|
77
77
|
if (formId)
|
|
78
78
|
result.formId = formId;
|
|
79
79
|
const decisionId = findAttr(ext, "zeebe:calledDecision", "decisionId");
|
|
80
|
+
const script = findAttr(ext, "zeebe:script", "expression");
|
|
80
81
|
if (decisionId) {
|
|
81
82
|
result.decisionId = decisionId;
|
|
82
83
|
const rv = findAttr(ext, "zeebe:calledDecision", "resultVariable");
|
|
83
84
|
if (rv)
|
|
84
85
|
result.resultVariable = rv;
|
|
85
86
|
}
|
|
87
|
+
else if (script) {
|
|
88
|
+
result.script = script;
|
|
89
|
+
const rv = findAttr(ext, "zeebe:script", "resultVariable");
|
|
90
|
+
if (rv)
|
|
91
|
+
result.resultVariable = rv;
|
|
92
|
+
}
|
|
86
93
|
else if (connector) {
|
|
87
94
|
if (headerResult !== undefined)
|
|
88
95
|
result.resultVariable = headerResult;
|
|
@@ -381,6 +388,13 @@ export function makeExtensions(el) {
|
|
|
381
388
|
children: [],
|
|
382
389
|
});
|
|
383
390
|
}
|
|
391
|
+
if (el.script) {
|
|
392
|
+
ext.push({
|
|
393
|
+
name: "zeebe:script",
|
|
394
|
+
attributes: { expression: el.script, resultVariable: el.resultVariable ?? "result" },
|
|
395
|
+
children: [],
|
|
396
|
+
});
|
|
397
|
+
}
|
|
384
398
|
const ioMapping = Object.entries(inputs).map(([target, source]) => ({
|
|
385
399
|
name: "zeebe:input",
|
|
386
400
|
attributes: { source, target },
|
|
@@ -91,6 +91,7 @@ const PATCH_EXTENSIONS = [
|
|
|
91
91
|
["formId", "zeebe:formDefinition"],
|
|
92
92
|
["calledProcess", "zeebe:calledElement"],
|
|
93
93
|
["decisionId", "zeebe:calledDecision"],
|
|
94
|
+
["script", "zeebe:script"],
|
|
94
95
|
["taskHeaders", "zeebe:taskHeaders"],
|
|
95
96
|
];
|
|
96
97
|
/**
|
|
@@ -139,7 +140,7 @@ function setTaskHeaders(element, headers) {
|
|
|
139
140
|
* `zeebe:calledDecision` instead.
|
|
140
141
|
*/
|
|
141
142
|
function setResultVariable(element, resultVariable) {
|
|
142
|
-
const calledDecision = element.extensionElements.find((e) => e.name === "zeebe:calledDecision");
|
|
143
|
+
const calledDecision = element.extensionElements.find((e) => e.name === "zeebe:calledDecision" || e.name === "zeebe:script");
|
|
143
144
|
if (calledDecision) {
|
|
144
145
|
calledDecision.attributes.resultVariable = resultVariable;
|
|
145
146
|
return;
|
|
@@ -199,6 +200,12 @@ function patchElement(element, patch) {
|
|
|
199
200
|
if (patch.decisionId !== undefined) {
|
|
200
201
|
setExtensionAttribute(element, "zeebe:calledDecision", "decisionId", patch.decisionId);
|
|
201
202
|
}
|
|
203
|
+
if (patch.script !== undefined) {
|
|
204
|
+
const script = ensureExtension(element, "zeebe:script");
|
|
205
|
+
script.attributes.expression = patch.script;
|
|
206
|
+
// Camunda will not deploy a script without the variable its value goes to
|
|
207
|
+
script.attributes.resultVariable ??= patch.resultVariable ?? "result";
|
|
208
|
+
}
|
|
202
209
|
if (patch.resultVariable !== undefined)
|
|
203
210
|
setResultVariable(element, patch.resultVariable);
|
|
204
211
|
if (patch.taskHeaders !== undefined)
|
|
@@ -43,6 +43,10 @@ export interface DeltaNode {
|
|
|
43
43
|
on?: string;
|
|
44
44
|
/** Zeebe job type, from `job=`. */
|
|
45
45
|
jobType?: string;
|
|
46
|
+
/** A script task's FEEL expression, with its leading `=`, from `feel=`. */
|
|
47
|
+
script?: string;
|
|
48
|
+
/** The variable a script task's or a job's result goes to, from `result=`. */
|
|
49
|
+
resultVariable?: string;
|
|
46
50
|
/** `nonint`: a non-interrupting boundary or start event. */
|
|
47
51
|
interrupting?: false;
|
|
48
52
|
line: number;
|
|
@@ -16,7 +16,7 @@
|
|
|
16
16
|
* @packageDocumentation
|
|
17
17
|
*/
|
|
18
18
|
import { CONNECTOR_LINE, parseConnectorLine } from "./connector-line.js";
|
|
19
|
-
import { ALIASES, KINDS, TRIGGERS, edgeLabel, tokenizePath, } from "./process-text.js";
|
|
19
|
+
import { ALIASES, KINDS, TRIGGERS, edgeLabel, splitFeel, tokenizePath, } from "./process-text.js";
|
|
20
20
|
/**
|
|
21
21
|
* Kind words the writer uses for element types the line format cannot create.
|
|
22
22
|
* A script may restate them on an existing node; it cannot declare a new one.
|
|
@@ -85,12 +85,21 @@ function readSpec(id, spec, line, problems) {
|
|
|
85
85
|
problems.push({ line, message: `unknown trigger "${trigger}" for "${id}"; ignored` });
|
|
86
86
|
}
|
|
87
87
|
}
|
|
88
|
-
|
|
88
|
+
const { plain, feel } = splitFeel(attrs);
|
|
89
|
+
if (feel !== undefined) {
|
|
90
|
+
// A step that evaluates FEEL is a script task
|
|
91
|
+
if (node.type === undefined || node.type === "task")
|
|
92
|
+
node.type = "scriptTask";
|
|
93
|
+
node.script = feel;
|
|
94
|
+
}
|
|
95
|
+
for (const attr of plain.split(/[\s,|]+/).filter(Boolean)) {
|
|
89
96
|
const [key, value] = attr.split("=", 2);
|
|
90
97
|
if (key === "on" && value)
|
|
91
98
|
node.on = value;
|
|
92
99
|
else if (key === "job" && value)
|
|
93
100
|
node.jobType = value;
|
|
101
|
+
else if (key === "result" && value)
|
|
102
|
+
node.resultVariable = value;
|
|
94
103
|
else if (key === "nonint" && value === undefined)
|
|
95
104
|
node.interrupting = false;
|
|
96
105
|
else
|
|
@@ -76,6 +76,12 @@ function spec(element, host) {
|
|
|
76
76
|
attrs.push("nonint");
|
|
77
77
|
if (element.jobType)
|
|
78
78
|
attrs.push(`job=${element.jobType}`);
|
|
79
|
+
if (element.script) {
|
|
80
|
+
// Last: feel= takes the rest of the attributes
|
|
81
|
+
if (element.resultVariable)
|
|
82
|
+
attrs.push(`result=${element.resultVariable}`);
|
|
83
|
+
attrs.push(`feel=${element.script.replace(/^=\s*/, "").replace(/\s+/g, " ")}`);
|
|
84
|
+
}
|
|
79
85
|
return `[${word}${trigger}${name}${attrs.length > 0 ? ` | ${attrs.join(" ")}` : ""}]`;
|
|
80
86
|
}
|
|
81
87
|
function label(flow) {
|
|
@@ -29,7 +29,7 @@ import { type ConnectorLine } from "./connector-line.js";
|
|
|
29
29
|
* It lives beside the parser so the two cannot drift: a test parses its example
|
|
30
30
|
* and expects no problems.
|
|
31
31
|
*/
|
|
32
|
-
export declare const PROCESS_TEXT_GUIDE = "Format \u2014 one path per line, nothing else:\n# Process name (first line)\na > b > c sequence flow\nid[kind Name] declare a node the first time it appears; afterwards write only id\ngw >(Label: condition) x conditional branch, condition in FEEL (amount > 1000, status = \"ok\")\ngw >(Label: default) y branch taken when no condition holds\nKinds: start end task user service rule (DMN decision) send receive script manual call xor and or eventgw catch (wait for message or timer) throw boundary\nEvents take a trigger: start:message end:error catch:timer boundary:error (timer message signal error escalation terminate conditional compensate cancel)\nAttributes after |: on=<task id> (required on boundary), nonint (non-interrupting), job=<job type>, each=<list variable> (once per item), after=<ISO duration> (timer)\nRules:\n- One start event. Every node is on a path from it to an end event: never a node nothing leads to.\n- An xor has two or more branches: exactly one is (Label: default), each other has a FEEL condition.\n- A boundary starts its own line, on a task you declared, and leads to a task that handles it; never draw an arrow into a boundary.\n- Branches that meet again are joined automatically; join parallel branches with an and node.\n- Steps done at the same time start from an and node and meet at another. A deadline is a boundary:timer with after= on the task that may run late. A step done for every item of a list takes each=<list>; use it only when the description says every or each.\n\nExample:\n# Expense approval\nstart[start Expense submitted] > check[xor Amount over 1000?]\ncheck >(Yes: amount > 1000) review[user Review expense] > pay[service Pay expense] > done[end Expense paid]\ncheck >(No: default) auto[service Approve automatically] > pay\nfailed[boundary:error Payment failed | on=pay] > notify[send Notify submitter] > notice[end Payment failed]";
|
|
32
|
+
export declare const PROCESS_TEXT_GUIDE = "Format \u2014 one path per line, nothing else:\n# Process name (first line)\na > b > c sequence flow\nid[kind Name] declare a node the first time it appears; afterwards write only id\ngw >(Label: condition) x conditional branch, condition in FEEL (amount > 1000, status = \"ok\")\ngw >(Label: default) y branch taken when no condition holds\nKinds: start end task user service rule (DMN decision) send receive script manual call xor and or eventgw catch (wait for message or timer) throw boundary\nEvents take a trigger: start:message end:error catch:timer boundary:error (timer message signal error escalation terminate conditional compensate cancel)\nAttributes after |: on=<task id> (required on boundary), nonint (non-interrupting), job=<job type>, each=<list variable> (once per item), after=<ISO duration> (timer), result=<variable>, feel=<FEEL expression> (last)\nRules:\n- One start event. Every node is on a path from it to an end event: never a node nothing leads to.\n- An xor has two or more branches: exactly one is (Label: default), each other has a FEEL condition.\n- A boundary starts its own line, on a task you declared, and leads to a task that handles it; never draw an arrow into a boundary.\n- A boundary leads only to the handling. What happens next when nothing fails follows the task itself (read > count), never the boundary.\n- A step that only works on process data (count, sum, filter, compare, pick, format a message) is a script task, never a service or plain task: its FEEL reads the variables earlier steps set with result=. read[service Read issues | result=issues] > count[script Count open issues | result=openCount feel=count(issues[state = \"open\"])]\n- Branches that meet again are joined automatically; join parallel branches with an and node.\n- Steps done at the same time start from an and node and meet at another. A deadline is a boundary:timer with after= on the task that may run late. A step done for every item of a list takes each=<list>; use it only when the description says every or each.\n\nExample:\n# Expense approval\nstart[start Expense submitted] > check[xor Amount over 1000?]\ncheck >(Yes: amount > 1000) review[user Review expense] > pay[service Pay expense] > done[end Expense paid]\ncheck >(No: default) auto[service Approve automatically] > pay\nfailed[boundary:error Payment failed | on=pay] > notify[send Notify submitter] > notice[end Payment failed]";
|
|
33
33
|
/** A line, or part of one, that {@link parseProcessText} could not use. */
|
|
34
34
|
export interface ProcessTextProblem {
|
|
35
35
|
/** 1-based line number in the text. */
|
|
@@ -83,6 +83,16 @@ export declare const KINDS: Record<string, BpmnElementType>;
|
|
|
83
83
|
export declare const ALIASES: Record<string, BpmnElementType>;
|
|
84
84
|
export declare const TRIGGERS: Set<string>;
|
|
85
85
|
export declare const EVENTS: Set<BpmnElementType>;
|
|
86
|
+
/**
|
|
87
|
+
* Splits `feel=` off a declaration's attributes. A FEEL expression has spaces and
|
|
88
|
+
* commas, so it takes the rest of them: `| result=open feel=count(issues[state = "open"])`.
|
|
89
|
+
*
|
|
90
|
+
* @returns The other attributes, and the expression with its leading `=`, if any.
|
|
91
|
+
*/
|
|
92
|
+
export declare function splitFeel(attrs: string): {
|
|
93
|
+
plain: string;
|
|
94
|
+
feel?: string;
|
|
95
|
+
};
|
|
86
96
|
/** A path line split into its parts. */
|
|
87
97
|
export interface PathTokens {
|
|
88
98
|
/** The nodes in the order written, each with the bracket text it was declared with, if any. */
|
|
@@ -38,11 +38,13 @@ gw >(Label: condition) x conditional branch, condition in FEEL (amount > 1000,
|
|
|
38
38
|
gw >(Label: default) y branch taken when no condition holds
|
|
39
39
|
Kinds: start end task user service rule (DMN decision) send receive script manual call xor and or eventgw catch (wait for message or timer) throw boundary
|
|
40
40
|
Events take a trigger: start:message end:error catch:timer boundary:error (timer message signal error escalation terminate conditional compensate cancel)
|
|
41
|
-
Attributes after |: on=<task id> (required on boundary), nonint (non-interrupting), job=<job type>, each=<list variable> (once per item), after=<ISO duration> (timer)
|
|
41
|
+
Attributes after |: on=<task id> (required on boundary), nonint (non-interrupting), job=<job type>, each=<list variable> (once per item), after=<ISO duration> (timer), result=<variable>, feel=<FEEL expression> (last)
|
|
42
42
|
Rules:
|
|
43
43
|
- One start event. Every node is on a path from it to an end event: never a node nothing leads to.
|
|
44
44
|
- An xor has two or more branches: exactly one is (Label: default), each other has a FEEL condition.
|
|
45
45
|
- A boundary starts its own line, on a task you declared, and leads to a task that handles it; never draw an arrow into a boundary.
|
|
46
|
+
- A boundary leads only to the handling. What happens next when nothing fails follows the task itself (read > count), never the boundary.
|
|
47
|
+
- A step that only works on process data (count, sum, filter, compare, pick, format a message) is a script task, never a service or plain task: its FEEL reads the variables earlier steps set with result=. read[service Read issues | result=issues] > count[script Count open issues | result=openCount feel=count(issues[state = "open"])]
|
|
46
48
|
- Branches that meet again are joined automatically; join parallel branches with an and node.
|
|
47
49
|
- Steps done at the same time start from an and node and meet at another. A deadline is a boundary:timer with after= on the task that may run late. A step done for every item of a list takes each=<list>; use it only when the description says every or each.
|
|
48
50
|
|
|
@@ -139,6 +141,29 @@ function matching(text, start, open, close) {
|
|
|
139
141
|
}
|
|
140
142
|
return -1;
|
|
141
143
|
}
|
|
144
|
+
/**
|
|
145
|
+
* Splits `feel=` off a declaration's attributes. A FEEL expression has spaces and
|
|
146
|
+
* commas, so it takes the rest of them: `| result=open feel=count(issues[state = "open"])`.
|
|
147
|
+
*
|
|
148
|
+
* @returns The other attributes, and the expression with its leading `=`, if any.
|
|
149
|
+
*/
|
|
150
|
+
export function splitFeel(attrs) {
|
|
151
|
+
const at = /(?:^|[\s,|])feel=/.exec(attrs);
|
|
152
|
+
if (!at)
|
|
153
|
+
return { plain: attrs };
|
|
154
|
+
const feel = attrs.slice(at.index + at[0].length).trim();
|
|
155
|
+
if (feel === "")
|
|
156
|
+
return { plain: attrs.slice(0, at.index) };
|
|
157
|
+
return { plain: attrs.slice(0, at.index), feel: feel.startsWith("=") ? feel : `= ${feel}` };
|
|
158
|
+
}
|
|
159
|
+
/** Words that name the handling of a failure, a timeout or a cancellation. */
|
|
160
|
+
const HANDLING = /\b(?:fail\w*|error\w*|handle\w*|alert\w*|notify\w*|retr(?:y|ies)|escalat\w*|cancel\w*|reject\w*|abort\w*|roll\s?back|compensat\w*|timeout|timed out|late)\b/i;
|
|
161
|
+
/** Whether `element` reads as the handling of what a boundary catches. */
|
|
162
|
+
function handles(element) {
|
|
163
|
+
if (element === undefined)
|
|
164
|
+
return false;
|
|
165
|
+
return HANDLING.test(element.name ?? "") || HANDLING.test(element.id.replace(/[_.-]+/g, " "));
|
|
166
|
+
}
|
|
142
167
|
/** The type a bare id suggests, for a node written without a kind or never declared. */
|
|
143
168
|
function typeFromId(id) {
|
|
144
169
|
// `pick > and`, `and > dispatch`: the kind written as if it were an id.
|
|
@@ -484,7 +509,7 @@ class Reader {
|
|
|
484
509
|
}
|
|
485
510
|
const bar = spec.indexOf("|");
|
|
486
511
|
// `boundary:timer on=poll`: an attribute written before the bar is one still
|
|
487
|
-
const loose = /\s+((?:on|job|each|after)=\S+|nonint)(?=\s|$)/g;
|
|
512
|
+
const loose = /\s+((?:on|job|each|after|result)=\S+|nonint)(?=\s|$)/g;
|
|
488
513
|
const beforeBar = bar < 0 ? spec : spec.slice(0, bar);
|
|
489
514
|
const head = beforeBar.replace(loose, "").trim();
|
|
490
515
|
const attrs = [...beforeBar.matchAll(loose)].map((m) => m[1]).join(" ") +
|
|
@@ -563,8 +588,9 @@ class Reader {
|
|
|
563
588
|
});
|
|
564
589
|
}
|
|
565
590
|
const node = { element, line: n, spec };
|
|
591
|
+
const { plain, feel } = splitFeel(attrs);
|
|
566
592
|
// `| on=pay | nonint`: a second bar is only another separator.
|
|
567
|
-
for (const attr of
|
|
593
|
+
for (const attr of plain.split(/[\s,|]+/).filter(Boolean)) {
|
|
568
594
|
const [key, value] = attr.split("=", 2);
|
|
569
595
|
if (key === "on" && value)
|
|
570
596
|
node.on = hostOf.get(value) ?? value;
|
|
@@ -601,9 +627,33 @@ class Reader {
|
|
|
601
627
|
}
|
|
602
628
|
element.timerDuration = duration(value);
|
|
603
629
|
}
|
|
630
|
+
else if (key === "result" && value && ACTIVITIES.has(element.type)) {
|
|
631
|
+
element.resultVariable = value;
|
|
632
|
+
}
|
|
604
633
|
else
|
|
605
634
|
this.problems.push({ line: n, message: `unknown attribute "${attr}" on "${id}"; ignored` });
|
|
606
635
|
}
|
|
636
|
+
if (feel !== undefined) {
|
|
637
|
+
// `calc[task Count open issues | feel=…]`: a step that evaluates FEEL is a script task
|
|
638
|
+
if (element.type === "task")
|
|
639
|
+
element.type = "scriptTask";
|
|
640
|
+
if (element.type === "scriptTask") {
|
|
641
|
+
element.script = feel;
|
|
642
|
+
element.resultVariable ??= id;
|
|
643
|
+
if (parseExpression(feel.slice(1)).errors.length > 0) {
|
|
644
|
+
this.problems.push({
|
|
645
|
+
line: n,
|
|
646
|
+
message: `feel= on "${id}" is not FEEL; kept for the reader to correct`,
|
|
647
|
+
});
|
|
648
|
+
}
|
|
649
|
+
}
|
|
650
|
+
else {
|
|
651
|
+
this.problems.push({
|
|
652
|
+
line: n,
|
|
653
|
+
message: `only a script task evaluates feel=; ignored on "${id}"`,
|
|
654
|
+
});
|
|
655
|
+
}
|
|
656
|
+
}
|
|
607
657
|
// `late[catch:timer | on=poll after=PT5M]`: an event on a task is a boundary event
|
|
608
658
|
const host = node.on === undefined ? undefined : this.nodes.get(node.on)?.element;
|
|
609
659
|
if (element.type === "intermediateCatchEvent" && host && ACTIVITIES.has(host.type)) {
|
|
@@ -880,6 +930,38 @@ function assemble(reader, final) {
|
|
|
880
930
|
const outOf = (id) => edges.filter((edge) => edge.from === id);
|
|
881
931
|
const into = (id) => edges.filter((edge) => edge.to === id);
|
|
882
932
|
if (final) {
|
|
933
|
+
// A boundary leads to the handling of what it catches, and to nothing else:
|
|
934
|
+
// the work that goes on when nothing goes wrong follows the task. A model
|
|
935
|
+
// often writes that work through the boundary instead (`read >
|
|
936
|
+
// err[boundary:error … | on=read] > handle`, then `err > count > post`),
|
|
937
|
+
// which would run it only when the task fails. The ways out named for
|
|
938
|
+
// handling it stay (the first, when none is), and the rest move to the task. A bare end the task led to goes: it only stood in for
|
|
939
|
+
// the work that now follows.
|
|
940
|
+
for (const node of [...nodes.values()]) {
|
|
941
|
+
const { id, type, attachedTo } = node.element;
|
|
942
|
+
if (type !== "boundaryEvent" || attachedTo === undefined)
|
|
943
|
+
continue;
|
|
944
|
+
const out = outOf(id);
|
|
945
|
+
if (out.length < 2)
|
|
946
|
+
continue;
|
|
947
|
+
const handling = out.filter((edge) => handles(nodes.get(edge.to)?.element));
|
|
948
|
+
const rest = handling.length > 0 ? out.filter((edge) => !handling.includes(edge)) : out.slice(1);
|
|
949
|
+
if (rest.length === 0)
|
|
950
|
+
continue;
|
|
951
|
+
for (const edge of outOf(attachedTo)) {
|
|
952
|
+
const end = nodes.get(edge.to)?.element;
|
|
953
|
+
if (end?.type !== "endEvent" || end.eventType !== undefined)
|
|
954
|
+
continue;
|
|
955
|
+
if (into(end.id).length > 1)
|
|
956
|
+
continue;
|
|
957
|
+
nodes.delete(end.id);
|
|
958
|
+
edges = edges.filter((other) => other !== edge);
|
|
959
|
+
fixes.push(`removed end event "${end.id}" after "${attachedTo}", whose work followed its boundary`);
|
|
960
|
+
}
|
|
961
|
+
for (const edge of rest)
|
|
962
|
+
edge.from = attachedTo;
|
|
963
|
+
fixes.push(`moved ${rest.map((edge) => `${id} > ${edge.to}`).join(", ")} onto "${attachedTo}": a boundary leads only to its handling`);
|
|
964
|
+
}
|
|
883
965
|
// One blank start: a process that starts twice with no trigger to tell the
|
|
884
966
|
// two apart is two processes. The later one goes, and what it led to is
|
|
885
967
|
// placed as any path nothing leads to is, below.
|