@uipath/maestro-builder-sdk 6.16.5 → 6.16.7

package/dist/bpmn/bpmn-expr-check.d.ts

@@ -22,7 +22,7 @@
  * Variables are SCOPED: a sub-process sees the enclosing variables plus its own.
  */
 import { type ExprDiagnostic } from '../core/expr-check.js';
-import { type BuiltBpmn } from './bpmn-sdk.js';
+import type { BuiltBpmn } from './bpmn-sdk.js';
 /** A diagnostic plus the element it was found in. */
 export interface BpmnLocatedDiagnostic extends ExprDiagnostic {
     where: string;

package/dist/bpmn/bpmn-expr-check.js

@@ -22,7 +22,7 @@
  * Variables are SCOPED: a sub-process sees the enclosing variables plus its own.
  */
 import { checkExpression } from '../core/expr-check.js';
-import { nodeDeclaredVars } from './bpmn-sdk.js';
+import { nodeDeclaredVars } from './declared-vars.js';
 const NOUN = 'variable';
 const NAMESPACE = 'vars';
 const BINDING_NOUN = 'binding';

package/dist/bpmn/bpmn-sdk.d.ts

@@ -27,6 +27,7 @@ import { type DataServiceOperation } from './data-service.js';
 export type { DataServiceOperation } from './data-service.js';
 export { BpmnBuildError } from './bpmn-expr-check.js';
 export type { BpmnLocatedDiagnostic } from './bpmn-expr-check.js';
+export { connectorOutputVars, nodeDeclaredVars, typedNodeDeclaredVars } from './declared-vars.js';
 /** ISO-8601 timer specification (one of duration / date / cycle). */
 export interface TimerSpec {
     /** Fire after this ISO-8601 duration, e.g. `'PT30S'`. */
@@ -3135,58 +3136,6 @@ export type BpmnConnectorOpts = ConnectorOpts & ActivityOpts & {
      */
     outputVar?: string;
 };
-/**
- * The variables a connector task's output rows land in.
- *
- * Per-node by default, because a `uipath:output`'s `var` IS the variable
- * declaration as far as the platform is concerned (its canvas model maps every
- * node output to a variable keyed by `var`). A shared name would therefore mean
- * two connectors writing one variable, with the second silently clobbering the
- * first — and it is the reason both the serializer and the expression check need
- * the same answer, hence one function.
- *
- * @param n - The connector node.
- * @returns The response and error variable names.
- *
- * @internal
- */
-export declare function connectorOutputVars(n: Extract<BpmnNode, {
-    kind: 'connector';
-}>): {
-    response: string;
-    error: string;
-};
-/**
- * The variables a typed node writes — the ONE definition of that set.
- *
- * It had grown three: this one (what an expression may read), `implicitNodeVars` in
- * serialize (what gets declared in `uipath:variables`), and `derivedVariableIds` in
- * decompile (what a decompiled file must NOT re-declare). All three must agree, and
- * adding `outputRows` proved they do not stay agreed on their own: two were updated,
- * this one was missed, and a human task's mapped output stopped being visible to the
- * expression checker — `vars.decision` reported undeclared for a variable the node
- * plainly writes. So serialize now calls this instead of repeating it, and only
- * decompile's copy is separate, which its own comment already flags as load-bearing.
- *
- * @param n - The typed node.
- * @returns The variable ids its output rows write.
- * @internal
- */
-export declare function typedNodeDeclaredVars(n: Extract<BpmnNode, {
-    kind: 'typed';
-}>): string[];
-/**
- * Every variable name a node DECLARES by writing to it — the platform counts a
- * node's output `var` as a declaration, so a downstream `=vars.<name>` resolves
- * against it without any `uipath:variables` entry. The expression check mirrors
- * that, or it would reject reads the platform accepts.
- *
- * @param n - The node to inspect.
- * @returns The variable names it declares, if any.
- *
- * @internal
- */
-export declare function nodeDeclaredVars(n: BpmnNode): string[];
 /** A sub-process body: the same graph methods, plus an internal node builder. */
 export declare class SubProcessBuilder extends ScopeBuilder {
     /**

package/dist/bpmn/bpmn-sdk.js

@@ -2,9 +2,11 @@ import { connector as makeConnector } from '../core/actions.js';
 import { checkBpmnExpressions, BpmnBuildError } from './bpmn-expr-check.js';
 import { BPMN_SCHEMA_VERSIONS } from './format-profile.js';
 import { schemaVersionRefusal } from '../schema-version.js';
-import { bindingRequiredFields, REGISTRY_GAPS, registryType, typedNodeOutputVar } from './typed-node.js';
+import { bindingRequiredFields, REGISTRY_GAPS, registryType } from './typed-node.js';
 import { DATA_SERVICE_ACTIVITY_TYPE, DATA_SERVICE_CONNECTOR_KEY, dataServiceWire } from './data-service.js';
 export { BpmnBuildError } from './bpmn-expr-check.js';
+// @internal helpers kept on the published /bpmn subpath; SDK code imports declared-vars.js.
+export { connectorOutputVars, nodeDeclaredVars, typedNodeDeclaredVars } from './declared-vars.js';
 function normTimer(t) {
     return typeof t === 'string' ? { duration: t } : t;
 }
@@ -2264,47 +2266,6 @@ class ScopeBuilder {
         return this;
     }
 }
-/**
- * The variables a connector task's output rows land in.
- *
- * Per-node by default, because a `uipath:output`'s `var` IS the variable
- * declaration as far as the platform is concerned (its canvas model maps every
- * node output to a variable keyed by `var`). A shared name would therefore mean
- * two connectors writing one variable, with the second silently clobbering the
- * first — and it is the reason both the serializer and the expression check need
- * the same answer, hence one function.
- *
- * @param n - The connector node.
- * @returns The response and error variable names.
- *
- * @internal
- */
-export function connectorOutputVars(n) {
-    return { response: n.outputVar ?? `${n.id}_response`, error: `${n.id}_Error` };
-}
-/**
- * The variables a typed node writes — the ONE definition of that set.
- *
- * It had grown three: this one (what an expression may read), `implicitNodeVars` in
- * serialize (what gets declared in `uipath:variables`), and `derivedVariableIds` in
- * decompile (what a decompiled file must NOT re-declare). All three must agree, and
- * adding `outputRows` proved they do not stay agreed on their own: two were updated,
- * this one was missed, and a human task's mapped output stopped being visible to the
- * expression checker — `vars.decision` reported undeclared for a variable the node
- * plainly writes. So serialize now calls this instead of repeating it, and only
- * decompile's copy is separate, which its own comment already flags as load-bearing.
- *
- * @param n - The typed node.
- * @returns The variable ids its output rows write.
- * @internal
- */
-export function typedNodeDeclaredVars(n) {
-    // Spelled-out rows REPLACE the derived pair, so they are the whole answer.
-    if (n.outputRows)
-        return n.outputRows.map((r) => r.var).filter((v) => v !== undefined);
-    const v = typedNodeOutputVar(n.id, n.type, n.outputVar, n.spec);
-    return [...(v ? [v] : []), ...Object.keys(n.outputs ?? {})];
-}
 /**
  * Fill in `activity` on a connector task from the `operation` beside it.
  *
@@ -2348,30 +2309,6 @@ function defaultActivityIdentityRows(type, context, rows) {
         return rows;
     return [...rows, { name: 'activity', type: 'string', value: operation }];
 }
-/**
- * Every variable name a node DECLARES by writing to it — the platform counts a
- * node's output `var` as a declaration, so a downstream `=vars.<name>` resolves
- * against it without any `uipath:variables` entry. The expression check mirrors
- * that, or it would reject reads the platform accepts.
- *
- * @param n - The node to inspect.
- * @returns The variable names it declares, if any.
- *
- * @internal
- */
-export function nodeDeclaredVars(n) {
-    if (n.kind === 'connector') {
-        const { response, error } = connectorOutputVars(n);
-        return [response, error];
-    }
-    if (n.kind === 'typed')
-        return typedNodeDeclaredVars(n);
-    if (n.kind === 'scriptTask')
-        return Object.keys(n.outputs);
-    if (n.kind === 'task')
-        return Object.keys(n.set);
-    return [];
-}
 /** A sub-process body: the same graph methods, plus an internal node builder. */
 export class SubProcessBuilder extends ScopeBuilder {
     /**

package/dist/bpmn/check-cli.js

@@ -16,8 +16,8 @@ import { resolveBpmnFile, loadBuiltBpmn } from './load.js';
 import { check } from './check.js';
 import { graphModel, renderGraph } from './graph.js';
 import { Bindings } from '../core/bindings.js';
-import { connectorCheckOpts, flagValue, openCliLibrary } from '../core/cli-library.js';
-import { runWhenInvokedDirectly } from '../cli-run.js';
+import { connectorCheckOpts, openCliLibrary } from '../core/cli-library.js';
+import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
 /** Flags that take a value — their argument is never the source positional. */
 const VALUE_FLAGS = new Set(['--library', '--connectors-local', '--bindings']);

package/dist/bpmn/check.d.ts

@@ -15,7 +15,7 @@
  * implicit join — the diagnostic is a `warning`, and its comment says which
  * platform rule it corresponds to and how the two differ.
  */
-import { type BuiltBpmn } from './bpmn-sdk.js';
+import type { BuiltBpmn } from './bpmn-sdk.js';
 import { type ConnectorCheckOpts } from '../core/connector-checks.js';
 import { type EventCheckOpts } from '../core/event-checks.js';
 export interface Diagnostic {

package/dist/bpmn/check.js

@@ -1,21 +1,4 @@
-/**
- * bpmn/check — fast static validation of a BuiltBpmn before serialization.
- *
- * Surfaces the common Maestro canvas-rule failures early (dangling flow refs,
- * duplicate ids, a gateway branch with no condition, a superfluous gateway, an
- * implicit join, a missing start event, a boundary event attached to nothing, an
- * empty timer) so authoring gets instant feedback. The authoritative gate is
- * still `uip maestro bpmn validate` (`validateBpmnCanvas`) on the emitted
- * `.bpmn`.
- *
- * **An `error` here must mirror a real platform rule.** Being stricter than
- * `validate` is worse than being looser: it refuses processes that deploy and run
- * correctly, and the author has no way to appeal. Where this file is deliberately
- * stricter than the platform — an unconditioned inclusive-gateway branch, an
- * implicit join — the diagnostic is a `warning`, and its comment says which
- * platform rule it corresponds to and how the two differ.
- */
-import { nodeDeclaredVars } from './bpmn-sdk.js';
+import { nodeDeclaredVars } from './declared-vars.js';
 import { allNodes, folderCompanionKeys, implicitNodeVars, processId } from './serialize.js';
 import { KNOWN_METHOD_SET } from './known-methods.js';
 import { EQUALS_EXPR_DIALECT, checkConnectorContract, checkConnectorLookups, checkConnectorSchema, checkBindingLabels, } from '../core/connector-checks.js';

package/dist/bpmn/compile-cli.js

@@ -23,13 +23,9 @@ import { serialize } from './serialize.js';
 import { check } from './check.js';
 import { Bindings } from '../core/bindings.js';
 import { connectorCheckOpts, openCliLibrary } from '../core/cli-library.js';
-import { runWhenInvokedDirectly } from '../cli-run.js';
+import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
 import { defaultBindingsFile } from '../workdir.js';
-function opt(argv, name) {
-    const i = argv.indexOf(name);
-    return i >= 0 ? argv[i + 1] : undefined;
-}
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
         console.error('usage: compile <bpmn.ts | BaseName> [-o out.bpmn] [--library <dir>] [--connectors-local <dir>] [--bindings <file>]');
@@ -50,7 +46,7 @@ export async function run(argv) {
     // without it, so a prepare resolved an operation against the live connection,
     // wrote the overlay, and compile ignored it.
     const library = openCliLibrary(argv);
-    const bindFile = opt(argv, '--bindings') ?? defaultBindingsFile();
+    const bindFile = flagValue(argv, '--bindings') ?? defaultBindingsFile();
     const bindings = new Bindings(bindFile);
     // The same facts `check-cli` runs on, from the instance about to serialize:
     // the inner loop and the emit rung must not disagree about a field or a
@@ -64,7 +60,7 @@ export async function run(argv) {
     }
     const xml = await serialize(built, { library, bindings });
     const base = basename(file).replace(/\.bpmn\.ts$|\.ts$/, '');
-    const out = opt(argv, '-o') ?? `${base}.bpmn`;
+    const out = flagValue(argv, '-o') ?? `${base}.bpmn`;
     writeFileSync(out, xml);
     console.log(`compile: wrote ${out} (${built.nodes.length} element(s))`);
     reportResult({ path: resolve(out), elements: built.nodes.length });

package/dist/bpmn/connector.d.ts

@@ -20,7 +20,7 @@
  */
 import type BpmnModdle from 'bpmn-moddle';
 import type { ModdleElement } from 'bpmn-moddle';
-import { type BpmnNode } from './bpmn-sdk.js';
+import type { BpmnNode } from './bpmn-sdk.js';
 import type { Library } from '../core/library.js';
 import type { Bindings } from '../core/bindings.js';
 type El = ModdleElement;

package/dist/bpmn/connector.js

@@ -1,7 +1,6 @@
-import { connectorOutputVars } from './bpmn-sdk.js';
-import { transportHttpMethod } from '../config.js';
+import { connectorOutputVars } from './declared-vars.js';
 import { EQUALS_EXPR_DIALECT } from '../core/connector-checks.js';
-import { buildConnectorInputs, nestConnectorBody } from '../core/connector-inputs.js';
+import { buildConnectorInputs, nestConnectorBody, transportHttpMethod } from '../core/connector-inputs.js';
 export function createConnectorTask(ctx, n) {
     const { m } = ctx;
     if (!ctx.library)

package/dist/bpmn/declared-vars.d.ts

@@ -0,0 +1,60 @@
+/**
+ * bpmn/declared-vars — which variables a BPMN node declares by writing to them.
+ *
+ * The builder, the expression check and the serializer all need the one answer.
+ * It lives outside `bpmn-sdk.ts` so the checker does not import the builder back
+ * (the runtime import cycle FB003 reported).
+ */
+import type { BpmnNode } from './bpmn-sdk.js';
+/**
+ * The variables a connector task's output rows land in.
+ *
+ * Per-node by default, because a `uipath:output`'s `var` IS the variable
+ * declaration as far as the platform is concerned (its canvas model maps every
+ * node output to a variable keyed by `var`). A shared name would therefore mean
+ * two connectors writing one variable, with the second silently clobbering the
+ * first — and it is the reason both the serializer and the expression check need
+ * the same answer, hence one function.
+ *
+ * @param n - The connector node.
+ * @returns The response and error variable names.
+ *
+ * @internal
+ */
+export declare function connectorOutputVars(n: Extract<BpmnNode, {
+    kind: 'connector';
+}>): {
+    response: string;
+    error: string;
+};
+/**
+ * The variables a typed node writes — the ONE definition of that set.
+ *
+ * It had grown three: this one (what an expression may read), `implicitNodeVars` in
+ * serialize (what gets declared in `uipath:variables`), and `derivedVariableIds` in
+ * decompile (what a decompiled file must NOT re-declare). All three must agree, and
+ * adding `outputRows` proved they do not stay agreed on their own: two were updated,
+ * this one was missed, and a human task's mapped output stopped being visible to the
+ * expression checker — `vars.decision` reported undeclared for a variable the node
+ * plainly writes. So serialize now calls this instead of repeating it, and only
+ * decompile's copy is separate, which its own comment already flags as load-bearing.
+ *
+ * @param n - The typed node.
+ * @returns The variable ids its output rows write.
+ * @internal
+ */
+export declare function typedNodeDeclaredVars(n: Extract<BpmnNode, {
+    kind: 'typed';
+}>): string[];
+/**
+ * Every variable name a node DECLARES by writing to it — the platform counts a
+ * node's output `var` as a declaration, so a downstream `=vars.<name>` resolves
+ * against it without any `uipath:variables` entry. The expression check mirrors
+ * that, or it would reject reads the platform accepts.
+ *
+ * @param n - The node to inspect.
+ * @returns The variable names it declares, if any.
+ *
+ * @internal
+ */
+export declare function nodeDeclaredVars(n: BpmnNode): string[];

package/dist/bpmn/declared-vars.js

@@ -0,0 +1,66 @@
+import { typedNodeOutputVar } from './typed-node.js';
+/**
+ * The variables a connector task's output rows land in.
+ *
+ * Per-node by default, because a `uipath:output`'s `var` IS the variable
+ * declaration as far as the platform is concerned (its canvas model maps every
+ * node output to a variable keyed by `var`). A shared name would therefore mean
+ * two connectors writing one variable, with the second silently clobbering the
+ * first — and it is the reason both the serializer and the expression check need
+ * the same answer, hence one function.
+ *
+ * @param n - The connector node.
+ * @returns The response and error variable names.
+ *
+ * @internal
+ */
+export function connectorOutputVars(n) {
+    return { response: n.outputVar ?? `${n.id}_response`, error: `${n.id}_Error` };
+}
+/**
+ * The variables a typed node writes — the ONE definition of that set.
+ *
+ * It had grown three: this one (what an expression may read), `implicitNodeVars` in
+ * serialize (what gets declared in `uipath:variables`), and `derivedVariableIds` in
+ * decompile (what a decompiled file must NOT re-declare). All three must agree, and
+ * adding `outputRows` proved they do not stay agreed on their own: two were updated,
+ * this one was missed, and a human task's mapped output stopped being visible to the
+ * expression checker — `vars.decision` reported undeclared for a variable the node
+ * plainly writes. So serialize now calls this instead of repeating it, and only
+ * decompile's copy is separate, which its own comment already flags as load-bearing.
+ *
+ * @param n - The typed node.
+ * @returns The variable ids its output rows write.
+ * @internal
+ */
+export function typedNodeDeclaredVars(n) {
+    // Spelled-out rows REPLACE the derived pair, so they are the whole answer.
+    if (n.outputRows)
+        return n.outputRows.map((r) => r.var).filter((v) => v !== undefined);
+    const v = typedNodeOutputVar(n.id, n.type, n.outputVar, n.spec);
+    return [...(v ? [v] : []), ...Object.keys(n.outputs ?? {})];
+}
+/**
+ * Every variable name a node DECLARES by writing to it — the platform counts a
+ * node's output `var` as a declaration, so a downstream `=vars.<name>` resolves
+ * against it without any `uipath:variables` entry. The expression check mirrors
+ * that, or it would reject reads the platform accepts.
+ *
+ * @param n - The node to inspect.
+ * @returns The variable names it declares, if any.
+ *
+ * @internal
+ */
+export function nodeDeclaredVars(n) {
+    if (n.kind === 'connector') {
+        const { response, error } = connectorOutputVars(n);
+        return [response, error];
+    }
+    if (n.kind === 'typed')
+        return typedNodeDeclaredVars(n);
+    if (n.kind === 'scriptTask')
+        return Object.keys(n.outputs);
+    if (n.kind === 'task')
+        return Object.keys(n.set);
+    return [];
+}

package/dist/bpmn/decompile-cli.js

@@ -26,15 +26,11 @@ import { typeStripDecision } from '../node-runtime.js';
 import { readFileSync } from 'node:fs';
 import { basename, resolve } from 'node:path';
 import { defaultSourceOut, writeSource } from '../workdir.js';
-import { runWhenInvokedDirectly } from '../cli-run.js';
+import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
 import { decompile } from './decompile.js';
 import { sameGraph } from './lift-verify.js';
 import { BPMN_IMPORT } from '../package-name.js';
 import { fileURLToPath } from 'node:url';
-function opt(argv, name) {
-    const i = argv.indexOf(name);
-    return i >= 0 ? argv[i + 1] : undefined;
-}
 /**
  * `run(argv)` is the tool contract the family-first `flow-sdk` CLI loads. It must
  * NOT read `process.argv`: under the unified CLI that still holds
@@ -45,7 +41,7 @@ export async function run(argv) {
         console.error('usage: decompile <Name.bpmn> [-o Name.bpmn.ts] [--import <specifier>] [--style explicit|nested] [--keep-flow-ids] [--keep-unused-bindings]');
         return 2;
     }
-    const style = opt(argv, '--style') ?? 'explicit';
+    const style = flagValue(argv, '--style') ?? 'explicit';
     if (style !== 'explicit' && style !== 'nested') {
         console.error(`decompile: --style must be explicit or nested, not "${style}"`);
         return 2;
@@ -76,7 +72,7 @@ export async function run(argv) {
         return 2;
     }
     const xml = readFileSync(input, 'utf8');
-    const importSpecifier = opt(argv, '--import') ?? BPMN_IMPORT;
+    const importSpecifier = flagValue(argv, '--import') ?? BPMN_IMPORT;
     let pruned = [];
     const base0 = { importSpecifier, keepUnusedBindings, onPrune: (ids) => (pruned = ids) };
     let source = await decompile(xml, base0);
@@ -103,7 +99,7 @@ export async function run(argv) {
         }
     }
     const base = basename(input).replace(/\.bpmn$/, '');
-    const out = opt(argv, '-o') ?? defaultSourceOut(`${base}.bpmn.ts`);
+    const out = flagValue(argv, '-o') ?? defaultSourceOut(`${base}.bpmn.ts`);
     writeSource(out, source);
     console.log(`decompile: wrote ${out}`);
     if (pruned.length) {

package/dist/bpmn/merge-cli.js

@@ -14,11 +14,7 @@ import { reportResult } from '../cli-result.js';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { basename, resolve } from 'node:path';
 import { mergeBpmn } from './merge.js';
-import { runWhenInvokedDirectly } from '../cli-run.js';
-function opt(argv, name) {
-    const i = argv.indexOf(name);
-    return i >= 0 ? argv[i + 1] : undefined;
-}
+import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
 export function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
         console.error('usage: bpmn-merge <original.bpmn> <edited.bpmn> [-o merged.bpmn] [--baseline <baseline.bpmn>]');
@@ -31,11 +27,11 @@ export function run(argv) {
         console.error('bpmn-merge: need <original.bpmn> and <edited.bpmn>');
         return 2;
     }
-    const baselinePath = opt(argv, '--baseline');
+    const baselinePath = flagValue(argv, '--baseline');
     const result = mergeBpmn(readFileSync(originalPath, 'utf8'), readFileSync(editedPath, 'utf8'), {
         ...(baselinePath ? { baseline: readFileSync(baselinePath, 'utf8') } : {}),
     });
-    const out = opt(argv, '-o') ?? 'merged.bpmn';
+    const out = flagValue(argv, '-o') ?? 'merged.bpmn';
     writeFileSync(out, result.xml);
     reportResult({ path: resolve(out), preserved: result.preserved.length, authored: result.authored.length, removed: result.removed.length });
     // Say what was kept and what was rewritten: on a surgical edit the preserved count

package/dist/bpmn/serialize.js

@@ -15,11 +15,10 @@
  */
 import BpmnModdle from 'bpmn-moddle';
 import { createRequire } from 'node:module';
-import { connectorOutputVars, } from './bpmn-sdk.js';
 import { createConnectorTask } from './connector.js';
 import { createConnectorEvent, createExternalTask, intsvcOutputVar } from './intsvc.js';
 import { createExtensionPayload, createTypedNode, rowDeclaration, typedNodeOutputVar, verbatimOutputRows } from './typed-node.js';
-import { typedNodeDeclaredVars } from './bpmn-sdk.js';
+import { connectorOutputVars, typedNodeDeclaredVars } from './declared-vars.js';
 const require = createRequire(import.meta.url);
 const uipathDescriptor = require('./uipath-moddle.v1.json');
 const NS = {

package/dist/bpmn/tidy-cli.js

@@ -15,11 +15,7 @@ import { reportResult } from '../cli-result.js';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { layoutProcess } from 'bpmn-auto-layout';
 import { finalizeBpmnXml } from './serialize.js';
-import { runWhenInvokedDirectly } from '../cli-run.js';
-function opt(argv, name) {
-    const i = argv.indexOf(name);
-    return i >= 0 ? argv[i + 1] : undefined;
-}
+import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
         console.error('usage: tidy <file.bpmn> [-o out.bpmn]');
@@ -32,7 +28,7 @@ export async function run(argv) {
         return 2;
     }
     const laidOut = finalizeBpmnXml(await layoutProcess(readFileSync(input, 'utf8')));
-    const out = opt(argv, '-o') ?? input;
+    const out = flagValue(argv, '-o') ?? input;
     writeFileSync(out, laidOut.endsWith('\n') ? laidOut : laidOut + '\n');
     const shapes = (laidOut.match(/BPMNShape/g) ?? []).length;
     console.log(`tidy: laid out ${out} (${shapes} shape(s))`);

package/dist/case/compile-cli.js

@@ -20,13 +20,9 @@ import { entryPointIO } from './entry-points.js';
 import { Bindings } from '../core/bindings.js';
 import { openCliLibrary } from '../core/cli-library.js';
 import { defaultBindingsFile } from '../workdir.js';
-import { runWhenInvokedDirectly } from '../cli-run.js';
+import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
 import { CASE_FORMAT_PROFILE } from './format-profile.js';
-function opt(argv, name) {
-    const i = argv.indexOf(name);
-    return i >= 0 ? argv[i + 1] : undefined;
-}
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
         console.error('usage: compile <case.ts | BaseName> [-o caseplan.json]');
@@ -57,10 +53,10 @@ export async function run(argv) {
     // also auto-detects the `connectors-local/` overlay `registry prepare` writes,
     // which is what the three copies of these lines used to each decide for itself.
     const library = openCliLibrary(argv);
-    const bindFile = opt(argv, '--bindings') ?? defaultBindingsFile();
+    const bindFile = flagValue(argv, '--bindings') ?? defaultBindingsFile();
     const bindings = new Bindings(bindFile);
     const caseplan = serialize(built, { library, bindings });
-    const out = opt(argv, '-o') ?? 'caseplan.json';
+    const out = flagValue(argv, '-o') ?? 'caseplan.json';
     writeFileSync(out, JSON.stringify(caseplan, null, 2) + '\n');
     const stages = caseplan.nodes.filter((n) => String(n.type).endsWith('Stage')).length;
     const triggers = syncEntryPoints(caseplan, out);

package/dist/case/decompile-cli.js

@@ -17,17 +17,13 @@
  */
 import { reportResult } from '../cli-result.js';
 import { mkdirSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { resolveLibraryDir } from '../registry/cache.js';
+import { resolveLibraryDir } from '../core/library-cache.js';
 import { basename, join, resolve } from 'node:path';
 import { defaultSourceOut, workDirBeside, writeSource } from '../workdir.js';
-import { runWhenInvokedDirectly } from '../cli-run.js';
+import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
 import { Library } from '../core/library.js';
 import { decompileWithDiagnostics } from './decompile.js';
 import { CASE_IMPORT } from '../package-name.js';
-function opt(argv, name) {
-    const i = argv.indexOf(name);
-    return i >= 0 ? argv[i + 1] : undefined;
-}
 /** Derive a PascalCase base name from the case name for the default output file. */
 function baseName(plan) {
     const src = plan.name ?? plan.id ?? 'Case';
@@ -56,16 +52,16 @@ export function run(argv) {
         return 2;
     }
     const plan = JSON.parse(readFileSync(pos, 'utf8'));
-    const libraryDir = resolveLibraryDir(opt(argv, '--library'));
+    const libraryDir = resolveLibraryDir(flagValue(argv, '--library'));
     const library = libraryDir && existsSync(`${libraryDir}/index.json`) ? new Library(libraryDir) : undefined;
-    const importSpecifier = opt(argv, '--import') ?? CASE_IMPORT;
+    const importSpecifier = flagValue(argv, '--import') ?? CASE_IMPORT;
     const bestEffort = argv.includes('--best-effort');
     const result = decompileWithDiagnostics(plan, {
         importSpecifier,
         library,
         bestEffort,
     });
-    const out = opt(argv, '-o') ?? defaultSourceOut(`${baseName(plan)}.case.ts`);
+    const out = flagValue(argv, '-o') ?? defaultSourceOut(`${baseName(plan)}.case.ts`);
     writeSource(out, result.source);
     console.log(`decompile: wrote ${basename(out)}`);
     reportResult({ path: resolve(out), diagnostics: result.diagnostics.map((d) => ({ code: d.code, location: d.location, message: d.message })) });

package/dist/case/merge-cli.js

@@ -13,11 +13,7 @@ import { reportResult } from '../cli-result.js';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { basename, resolve } from 'node:path';
 import { mergeCase } from './merge.js';
-import { runWhenInvokedDirectly } from '../cli-run.js';
-function opt(argv, name) {
-    const i = argv.indexOf(name);
-    return i >= 0 ? argv[i + 1] : undefined;
-}
+import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
 export function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
         console.error('usage: case-merge <original.json> <edited.json> [-o merged.json]');
@@ -35,7 +31,7 @@ export function run(argv) {
     const merged = mergeCase(original, edited, {
         warn: (message) => console.error(`case-merge: warning: ${message}`),
     });
-    const out = opt(argv, '-o') ?? 'merged.caseplan.json';
+    const out = flagValue(argv, '-o') ?? 'merged.caseplan.json';
     writeFileSync(out, JSON.stringify(merged, null, 2) + '\n');
     const stages = (merged.nodes ?? [])
         .filter((node) => String(node.type ?? '').endsWith('Stage')).length;

package/dist/case/serialize.js

@@ -9,7 +9,7 @@
  * name) are resolved here to the generated ids.
  */
 import { IdGen } from './ids.js';
-import { transportHttpMethod } from '../config.js';
+import { transportHttpMethod } from '../core/connector-inputs.js';
 import { refuseLookupToken } from '../core/lookups.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { resolveSchemaVersion } from '../schema-version.js';