@uipath/maestro-builder-sdk 6.16.14 → 6.17.1

package/dist/core/library.js

@@ -9,10 +9,26 @@
 import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { prepareCommand } from './cli-spelling.js';
+import { PULL_COMMAND } from './library-cache.js';
 import { editDistance } from './edit-distance.js';
 import { loadListEnvelopes, lookupListEnvelope } from './list-envelope.js';
 import { lookupSpecOf } from './lookups.js';
 import { loadByoaLedger, loadInvariantCollections, loadLookupResolutions } from './lookup-store.js';
+/**
+ * The refusal {@link Library.resolve} throws, with a `code` for each reason.
+ *
+ * Typed so a caller can tell a refusal from a bug without matching on message
+ * text: `check` reports it under this code with this message, and a compile
+ * that throws it carries the same code into its `--json` diagnostics (#948).
+ */
+export class ConnectorResolveError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'ConnectorResolveError';
+        this.code = code;
+    }
+}
 export class Library {
     layers = [];
     /** The LIST-ENVELOPE LEDGER, overlay first so a prepared entry can add a row. */
@@ -582,7 +598,7 @@ export class Library {
                 + `the library index (\`index.json\`), and remember the two namespaces: `
                 + `\`…connector.trigger.…\` starts a flow, \`…connector.event.…\` waits mid-flow.`
             : '';
-        throw new Error(`connector not in library: ${nodeType}${version ? '@' + version : ''}.${hint}`
+        throw new ConnectorResolveError('CONNECTOR_NOT_IN_LIBRARY', `connector not in library: ${nodeType}${version ? '@' + version : ''}.${hint}`
             + this.describeMiss(nodeType, version, objectName));
     }
     /**
@@ -622,7 +638,7 @@ export class Library {
             + where
             + ' Note the operation slug is the nodeType segment, NOT the tenant\'s `objectName`'
             + ' — `uip maestro case spec` reports the latter, and the two can differ.'
-            + ' If the operation is newer than the library, refresh it with `uip maestro flow registry pull --force`.';
+            + ` If the operation is newer than the library, refresh it with \`${PULL_COMMAND}\`.`;
     }
     /** Every direct operation id under `prefix` (no further dot), across layers, sorted and de-duplicated. */
     opsUnder(prefix) {
@@ -646,7 +662,7 @@ export class Library {
         return ` No connector "${key}" in the library (${keys.length} indexed).`
             + (near && near !== key ? ` Closest: ${near}.` : '')
             + where
-            + ' If the connector is newer than the library, refresh it with `uip maestro flow registry pull --force`.';
+            + ` If the connector is newer than the library, refresh it with \`${PULL_COMMAND}\`.`;
     }
     /**
      * The event half of {@link describeMiss}: which of the connector's EVENTS the
@@ -666,7 +682,7 @@ export class Library {
         const waits = this.opsUnder(`uipath.connector.event.${key}.`);
         // A start trigger resolves from either form; a mid-flow wait needs the `.event.` form itself.
         const usable = kind === 'trigger' ? [...new Set([...starts, ...waits])].sort() : waits;
-        const refresh = ' If the event is newer than the library, refresh it with `uip maestro flow registry pull --force`.';
+        const refresh = ` If the event is newer than the library, refresh it with \`${PULL_COMMAND}\`.`;
         if (usable.length) {
             if (usable.includes(asked)) {
                 // Only a version can make a carried event miss here: every other refusal
@@ -755,7 +771,7 @@ export class Library {
                         + `dispatch. If it is a typo, compile will not catch it.\n`);
                     return this.build(layer.dir, { ...only, objectName }, nodeType, { objectNameUnverified: true });
                 }
-                throw new Error(`connector ${nodeType} does not have an object "${objectName}": it is a single, `
+                throw new ConnectorResolveError('CONNECTOR_OBJECT_NOT_GENERIC', `connector ${nodeType} does not have an object "${objectName}": it is a single, `
                     + `non-generic operation addressing ${only.objectName ? `"${only.objectName}"` : 'no object'}. `
                     + `Drop the \`object\` option (it is only for generic operations, whose node type covers many objects).`);
             }
@@ -769,7 +785,7 @@ export class Library {
             .filter((o) => typeof o === 'string' && o.length > 0)
             .sort();
         if (objectName === undefined) {
-            throw new Error(`connector ${nodeType} is a GENERIC operation covering ${matches.length} objects — `
+            throw new ConnectorResolveError('CONNECTOR_OBJECT_REQUIRED', `connector ${nodeType} is a GENERIC operation covering ${matches.length} objects — `
                 + `say which one with the \`object\` option, e.g. `
                 + `connector('${nodeType.split('.').slice(2, 3)[0]}', '${nodeType.split('.').slice(3).join('.')}', `
                 + `{ … }, { object: '${objects[0] ?? '<object>'}' }). ${describeObjects(objects)}`);

package/dist/core/script-return.js

@@ -28,7 +28,7 @@
  * into a designer error — the exact defect this file exists to remove, pointed
  * the other way.
  */
-import * as ts from 'typescript';
+import { typescript } from './typescript-module.js';
 /** Normalize whatever the author wrote into the emitted shape. */
 export function declaredScriptShape(returns) {
     if (typeof returns === 'string')
@@ -59,6 +59,7 @@ export function declaredScriptShape(returns) {
  * fields written down says so with `returns: {…}`.
  */
 export function inferScriptShape(code) {
+    const ts = typescript();
     // Wrap so a top-level `return` parses — this is how the runtime executes it.
     const sf = ts.createSourceFile('script.ts', `function __block() {\n${code}\n}`, ts.ScriptTarget.ES2020, true);
     // `var d = Math.floor(...); return { days: d }` is how these bodies are
@@ -99,6 +100,7 @@ export function inferScriptShape(code) {
 }
 /** The type of one expression, or undefined when it is not written down. */
 function typeOf(expr, locals, depth) {
+    const ts = typescript();
     // Bounded: a local initialized from another local is followed, a cycle is not.
     if (depth > 8)
         return undefined;
@@ -163,6 +165,7 @@ function typeOf(expr, locals, depth) {
 }
 /** `a + b`, comparisons, and the short-circuit operators. */
 function binaryShape(e, locals, depth) {
+    const ts = typescript();
     const op = e.operatorToken.kind;
     // A comparison is a boolean whatever its operands are.
     if (op === ts.SyntaxKind.EqualsEqualsToken || op === ts.SyntaxKind.EqualsEqualsEqualsToken

package/dist/core/typed-raw-node.js

@@ -55,6 +55,7 @@ export const TYPED_FACTORIES = {
     'core.logic.switch': { factory: '.switch()', bundled: ['1.0.0', '1.1'] },
     'core.logic.terminate': { factory: '.terminate()', bundled: ['1.0.0', '1.0'] },
     'core.subflow': { factory: 'subflow(child, inputs)', bundled: ['1.0.0', '1.0'] },
+    'uipath.agent.autonomous': { factory: 'inlineAgent()', bundled: ['1.2', '1.3', '1.4'] },
     'uipath.agent.conversational': { factory: 'conversationalAgent()', bundled: ['1.6', '1.7'] },
     'uipath.agent.voice': { factory: 'voiceAgent()', bundled: ['1.0', '1.1'] },
     'uipath.conversational.get-conversation-context': { factory: 'conversationContext()', bundled: ['1.0'] },

package/dist/core/typescript-module.d.ts

@@ -0,0 +1,2 @@
+import type * as TS from 'typescript';
+export declare function typescript(): typeof TS;

package/dist/core/typescript-module.js

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+/**
+ * The TypeScript compiler, loaded on first use.
+ *
+ * Every builder entry reaches the expression and script checkers, and loading the compiler
+ * costs ~120 ms that a flow which never runs those checks should not pay (FB009). The
+ * specifier stays a literal at the call so the architecture lint sees the edge (as a lazy
+ * one); FB005 keeps this the only definition.
+ *
+ * The triple-slash reference: tests type-check generated code against `flow-sdk.ts`'s
+ * import graph without `@types/node` in scope, and this is the one `node:` import in that
+ * graph. Without it they fail with TS2307 on 'node:module'. It is not emitted into the .d.ts.
+ */
+import { createRequire } from 'node:module';
+let typescriptModule;
+export function typescript() {
+    return (typescriptModule ??= createRequire(import.meta.url)('typescript'));
+}

package/dist/core-definitions.json

@@ -8852,6 +8852,216 @@
       ]
     }
   },
+  "uipath.agent.autonomous@1.2": {
+    "nodeType": "uipath.agent.autonomous",
+    "version": "1.2",
+    "category": "agent",
+    "description": "AI agent that completes tasks autonomously",
+    "tags": [
+      "agentic",
+      "ai",
+      "autonomous",
+      "agent"
+    ],
+    "sortOrder": 5,
+    "supportsErrorHandling": true,
+    "display": {
+      "label": "Autonomous Agent",
+      "icon": "autonomous-agent",
+      "shape": "rectangle"
+    },
+    "handleConfiguration": [
+      {
+        "position": "top",
+        "handles": [
+          {
+            "id": "escalation",
+            "type": "source",
+            "handleType": "artifact",
+            "label": "Escalations",
+            "showButton": true,
+            "constraints": {
+              "allowedTargets": [
+                {
+                  "nodeType": "uipath.agent.resource.escalation"
+                },
+                {
+                  "nodeType": "uipath.agent.resource.escalation.*"
+                }
+              ],
+              "validationMessage": "Only Agent Escalation nodes can connect here"
+            }
+          }
+        ]
+      },
+      {
+        "position": "bottom",
+        "handles": [
+          {
+            "id": "context",
+            "type": "source",
+            "handleType": "artifact",
+            "label": "Context",
+            "showButton": true,
+            "constraints": {
+              "allowedTargets": [
+                {
+                  "nodeType": "uipath.agent.resource.context.*"
+                }
+              ],
+              "validationMessage": "Only Context resource nodes can connect here"
+            }
+          },
+          {
+            "id": "tool",
+            "type": "source",
+            "handleType": "artifact",
+            "label": "Tools",
+            "showButton": true,
+            "constraints": {
+              "allowedTargets": [
+                {
+                  "nodeType": "uipath.agent.resource.tool.*"
+                }
+              ],
+              "validationMessage": "Only Tool resource nodes can connect here"
+            }
+          }
+        ]
+      },
+      {
+        "position": "left",
+        "handles": [
+          {
+            "id": "input",
+            "type": "target",
+            "handleType": "input"
+          }
+        ]
+      },
+      {
+        "position": "right",
+        "handles": [
+          {
+            "id": "success",
+            "type": "source",
+            "handleType": "output",
+            "isDefaultForType": true
+          },
+          {
+            "id": "error",
+            "type": "source",
+            "handleType": "output",
+            "label": "Error",
+            "visible": "{inputs.errorHandlingEnabled}",
+            "constraints": {
+              "maxConnections": 1
+            }
+          }
+        ]
+      }
+    ],
+    "inputDefinition": {
+      "type": "object",
+      "properties": {
+        "systemPrompt": {
+          "type": "string",
+          "minLength": 1,
+          "errorMessage": {
+            "minLength": "System prompt is required"
+          }
+        },
+        "userPrompt": {
+          "type": "string",
+          "minLength": 1,
+          "errorMessage": {
+            "minLength": "User prompt is required"
+          }
+        },
+        "model": {
+          "type": "string",
+          "minLength": 1,
+          "errorMessage": {
+            "minLength": "Model is required"
+          }
+        },
+        "temperature": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1
+        },
+        "maxTokenPerResponse": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 16384
+        },
+        "modelMaxTokens": {
+          "type": "number",
+          "minimum": 0
+        },
+        "maxIterations": {
+          "type": "number",
+          "minimum": 1,
+          "maximum": 100
+        },
+        "guardrails": {
+          "type": "array"
+        },
+        "agentInputVariables": {
+          "type": "array"
+        },
+        "agentOutputVariables": {
+          "type": "array"
+        }
+      },
+      "required": [
+        "systemPrompt",
+        "userPrompt",
+        "model"
+      ]
+    },
+    "inputDefaults": {},
+    "outputDefinition": {
+      "output": {
+        "type": "object",
+        "description": "Agent response",
+        "source": "=result.response",
+        "var": "output"
+      },
+      "error": {
+        "type": "object",
+        "description": "Error information if the node fails",
+        "source": "=Error",
+        "var": "error"
+      }
+    },
+    "model": {
+      "source": true,
+      "type": "bpmn:ServiceTask",
+      "serviceType": "Orchestrator.StartInlineAgentJob",
+      "version": "v2",
+      "context": [
+        {
+          "name": "_label",
+          "type": "string",
+          "value": ""
+        },
+        {
+          "name": "name",
+          "type": "string",
+          "value": ""
+        },
+        {
+          "name": "entryPoint",
+          "type": "string",
+          "value": ""
+        }
+      ]
+    },
+    "debug": {
+      "runtime": "bpmnEngine"
+    }
+  },
   "uipath.agent.autonomous@1.3": {
     "nodeType": "uipath.agent.autonomous",
     "version": "1.3",

package/dist/decompile-cli.js

@@ -25,6 +25,7 @@ import { decompile } from './decompile.js';
 import { resolveFlowRefs } from './ref-resolve.js';
 import { flagValue, runWhenInvokedDirectly } from './cli-run.js';
 import { PACKAGE_NAME } from './package-name.js';
+import { commentText } from './core/comment-text.js';
 /** Derive a PascalCase base name from the flow name/id for the default output file. */
 function baseName(flow) {
     const src = flow.name ?? flow.id ?? 'Flow';
@@ -101,7 +102,7 @@ function pipelineScript(originalPath, tsPath, pipelinePath) {
     const base = pipelinePath.replace(/\.pipeline\.mjs$/, '');
     return `#!/usr/bin/env node
 // Generated by flow-decompile — the brownfield read/modify/write pipeline for
-// ${basename(originalPath)}. Run it, edit ${basename(tsPath)}, run it again.
+// ${commentText(basename(originalPath))}. Run it, edit ${commentText(basename(tsPath))}, run it again.
 import { execFileSync, spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 

package/dist/decompile.js

@@ -35,6 +35,7 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { inferScriptShape } from './core/script-return.js';
 import { DEFAULT_TRIGGER_ID } from './core/expr.js';
+import { commentText } from './core/comment-text.js';
 import { parseIxpProjectType } from './core/actions.js';
 import { readFlowGlobals } from './flow-variables.js';
 import { missingBindingLabels } from './core/binding-messages.js';
@@ -95,7 +96,19 @@ function warnOnce(message) {
  * emitted source; saying so here is the difference between a loop that fails
  * at step 2 with a hint and one that fails at step 2 with a puzzle.
  */
-const CORE_DEFINITION_KEYS = new Set(Object.keys(JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), 'core-definitions.json'), 'utf8'))));
+const CORE_DEFINITIONS = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), 'core-definitions.json'), 'utf8'));
+const CORE_DEFINITION_KEYS = new Set(Object.keys(CORE_DEFINITIONS));
+/**
+ * The label the canvas gives a freshly dropped `node`: its definition's
+ * `display.label`, from the file's own `definitions[]`, else the bundled core
+ * definition. `serialize` uses the same label when the author sets none.
+ */
+function definitionLabel(node) {
+    const key = `${node.type}@${node.typeVersion}`;
+    const def = runDefs.get(key) ?? CORE_DEFINITIONS[key] ?? runDefs.get(node.type);
+    const label = def?.display?.label;
+    return typeof label === 'string' ? label : undefined;
+}
 function verClause(node) {
     const tv = node.typeVersion;
     if (!tv) {
@@ -124,6 +137,25 @@ function verArg(node) {
     const clause = verClause(node);
     return clause ? `, { ${clause} }` : '';
 }
+/**
+ * A trigger node's option clauses: its exact `version`, and its canvas `label`
+ * when that differs from the definition's label (`definitionLabel`).
+ */
+function triggerOptParts(node) {
+    const parts = [];
+    const ver = verClause(node);
+    if (ver)
+        parts.push(ver);
+    const label = node.display?.label;
+    if (typeof label === 'string' && label !== definitionLabel(node))
+        parts.push(`label: ${str(label)}`);
+    return parts;
+}
+/** `triggerOptParts` as the `.trigger(spec, { ... })` options argument. */
+function triggerOptsArg(node) {
+    const parts = triggerOptParts(node);
+    return parts.length ? `, { ${parts.join(', ')} }` : '';
+}
 /**
  * The full node-options argument for steps that can carry both an exact
  * `version` and mid-flow `updates` (the format's `variableUpdates[nodeId]`,
@@ -1083,11 +1115,12 @@ function sidecarAgentInputs(node) {
         ? numberUnless(settings.maxIterations, STUDIO_WEB_DEFAULT_MAX_ITERATIONS)
         : typeof settings.maxIterations === 'number' ? settings.maxIterations : undefined;
     // `mode` is a harness choice on the inline agent only; the conversational and
-    // voice sidecars always carry their family's fixed value. Naming it is also
-    // what selects the 1.3 definition, so on a 1.3 node even `'standard'` was the
-    // author's.
+    // voice sidecars always carry their family's fixed value. `'standard'` is the
+    // sidecar's default, so only another value is the author's. (Naming it no
+    // longer selects a definition version — the node's `{ version }` carries that,
+    // flow-builder-sdk#956.)
     const mode = node.type === T.inlineAgent && typeof settings.mode === 'string'
-        && (settings.mode !== 'standard' || node.typeVersion === '1.3')
+        && settings.mode !== 'standard'
         ? settings.mode : undefined;
     return {
         ...(system === undefined ? {} : { systemPrompt: system }),
@@ -1616,7 +1649,7 @@ function unboundMarker(node, labels, key, action) {
         + `The source leaves ${missing.length > 1 ? 'them' : 'it'} out, and compile refuses the node (BINDING_MISSING) `
         + `until it names both labels: run \`${prepareCommand(key, action ?? '<action>')}\`, then pass `
         + `\`connection\` and \`folder\`.`);
-    return ` /* TODO: bind ${names}; compile refuses this node until it has both labels (BINDING_MISSING) */`;
+    return ` /* TODO: bind ${commentText(names)}; compile refuses this node until it has both labels (BINDING_MISSING) */`;
 }
 function emitEventSubscription(node, imp, inputNames) {
     const prefix = node.type.startsWith('uipath.connector.event.') ? 'uipath.connector.event.'
@@ -1705,6 +1738,13 @@ function emitPublishedResource(node, imp, inputNames) {
     // definition to read there is nothing to recover it from.
     const name = binding('name');
     const folderPath = binding('folderPath');
+    // A sibling project of the same solution (#951): the model names its project
+    // instead of a folder. `isInSolution` is flow-core's marker; an in-solution
+    // agent emitted before #951 carries only `projectId`. Read back as
+    // `location: 'in-solution'` so the recompile takes the in-solution path
+    // instead of a published one with an empty folder.
+    const projectId = typeof def?.model?.projectId === 'string' ? def.model.projectId : undefined;
+    const inSolution = def?.model?.isInSolution === true || projectId !== undefined;
     const inputs = { ...(node.inputs ?? {}) };
     // The design-time fire-and-forget switch is an OPTION on the factory, not a
     // process argument — serialize adds it to `inputs` after rendering the
@@ -1720,7 +1760,9 @@ function emitPublishedResource(node, imp, inputNames) {
     return `${imp.use(family.factory)}(${opts([
         ['key', str(key)],
         ['name', name !== undefined ? str(name) : undefined],
-        ['folderPath', folderPath !== undefined ? str(folderPath) : undefined],
+        ['location', inSolution ? str('in-solution') : undefined],
+        ['folderPath', !inSolution && folderPath !== undefined ? str(folderPath) : undefined],
+        ['projectId', inSolution && projectId !== undefined ? str(projectId) : undefined],
         ['inputs', inputRows.length ? objLit(inputRows) : undefined],
         ['returns', returns],
         ['form', family.form !== undefined ? str(family.form) : undefined],
@@ -1792,7 +1834,7 @@ function unsupportedSpec(node, imp, o) {
     }
     // No definition to carry: a mock publishes nothing and takes no inputs, so it
     // is a safe structural stand-in, and the marker records what it replaced.
-    return `${imp.use('mock')}() /* TODO: unsupported node type ${node.type} */`;
+    return `${imp.use('mock')}() /* TODO: unsupported node type ${commentText(node.type)} */`;
 }
 /** `some-node.id` → `someNodeId`, for a hoisted const name. */
 function camel(id) {
@@ -1902,39 +1944,39 @@ function emitTrigger(e, depth, trigger, imp, o, inputNames = new Set()) {
         // The default trigger, spelled out: decompiled source is deliberately more
         // explicit than hand-authored source so the node's exact definition version
         // survives recompilation (design §5.3).
-        e.line(depth, `.trigger(${imp.use('manual')}()${verArg(trigger)})`);
+        e.line(depth, `.trigger(${imp.use('manual')}()${triggerOptsArg(trigger)})`);
         return;
     }
     if (trigger.type === T.triggerScheduled) {
-        e.line(depth, `.trigger(${imp.use('scheduled')}(${opts([['every', str(scheduleEvery(trigger))]])})${verArg(trigger)})`);
+        e.line(depth, `.trigger(${imp.use('scheduled')}(${opts([['every', str(scheduleEvery(trigger))]])})${triggerOptsArg(trigger)})`);
         return;
     }
     if (trigger.type === T.triggerForm) {
         // The schema is DERIVED from the flow's inputs at compile time, so nothing
         // of it needs recovering — the factory takes no arguments.
-        e.line(depth, `.trigger(${imp.use('formTrigger')}()${verArg(trigger)})`);
+        e.line(depth, `.trigger(${imp.use('formTrigger')}()${triggerOptsArg(trigger)})`);
         return;
     }
     if (trigger.type === T.triggerConversation) {
-        e.line(depth, `.trigger(${imp.use('conversationTrigger')}()${verArg(trigger)})`);
+        e.line(depth, `.trigger(${imp.use('conversationTrigger')}()${triggerOptsArg(trigger)})`);
         return;
     }
     if (trigger.type === T.triggerVoice) {
-        e.line(depth, `.trigger(${imp.use('voiceTrigger')}()${verArg(trigger)})`);
+        e.line(depth, `.trigger(${imp.use('voiceTrigger')}()${triggerOptsArg(trigger)})`);
         return;
     }
     // A connector EVENT trigger — the same subscription body as a mid-flow wait.
     {
         const sub = emitEventSubscription(trigger, imp, inputNames);
         if (sub !== undefined) {
-            e.line(depth, `.trigger(${imp.use('onEvent')}(${sub})${verArg(trigger)})`);
+            e.line(depth, `.trigger(${imp.use('onEvent')}(${sub})${triggerOptsArg(trigger)})`);
             return;
         }
     }
     if (o.bestEffort === false) {
         throw new Error(`decompile: unsupported trigger type "${trigger.type}".`);
     }
-    e.line(depth, `/* TODO: unsupported trigger type ${trigger.type} */`);
+    e.line(depth, `/* TODO: unsupported trigger type ${commentText(trigger.type)} */`);
 }
 // ─── Control-flow reconstruction (Phase 3) ────────────────────────────────────
 //
@@ -2350,7 +2392,7 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
         // Unstructured fan-out we can't fold — best-effort marker.
         if (ctx.o.bestEffort === false)
             throw new Error(`decompile: unstructured fan-out at "${node.id}".`);
-        segs.push(`/* TODO: unstructured fan-out at ${node.id} (${succ.length} successors) */`);
+        segs.push(`/* TODO: unstructured fan-out at ${commentText(node.id)} (${commentText(succ.length)} successors) */`);
         return segs;
     }
     return segs;
@@ -2637,7 +2679,7 @@ function emitSubflow(node, ctx) {
     if (!child) {
         if (ctx.o.bestEffort === false)
             throw new Error(`decompile: subflow "${node.id}" has no body in subflows[].`);
-        return `${ctx.imp.use('mock')}() /* TODO: subflow ${node.id} body missing */`;
+        return `${ctx.imp.use('mock')}() /* TODO: subflow ${commentText(node.id)} body missing */`;
     }
     const childName = `${node.id}Child`;
     const childSrc = emitChildFlow(childName, child, ctx);
@@ -2736,7 +2778,7 @@ export function decompile(flow, options = {}) {
         if (runStrict)
             throw new Error(`decompile: ${schema.problem}`);
         warnOnce(schema.problem);
-        e.line(d, `// TODO: ${schema.problem}`);
+        e.line(d, `// TODO: ${commentText(schema.problem)}`);
     }
     if (flow.name !== undefined && flow.name !== flow.id)
         e.line(d, `.name(${str(flow.name)})`);
@@ -2772,7 +2814,7 @@ export function decompile(flow, options = {}) {
             throw new Error(`decompile: ${message}`);
         warnOnce(message);
         for (const n of detached) {
-            e.line(d, `// TODO: node ${str(n.id)} (${n.type}) is not reachable from any trigger and is NOT in this source; recompiling drops it. Connect it in the .flow or edit its JSON directly.`);
+            e.line(d, `// TODO: node ${commentText(str(n.id))} (${commentText(n.type)}) is not reachable from any trigger and is NOT in this source; recompiling drops it. Connect it in the .flow or edit its JSON directly.`);
         }
     }
     // `{ shared }` input copies on the roots (#924). Any other trigger-level
@@ -2786,7 +2828,7 @@ export function decompile(flow, options = {}) {
         if (runStrict)
             throw new Error(`decompile: ${message}`);
         warnOnce(message);
-        e.line(d, `// TODO: ${message}`);
+        e.line(d, `// TODO: ${commentText(message)}`);
     }
     emitVariables(e, d, flow, imp, new Set(triggerNodes.filter((t) => t !== trigger).map((t) => t.id)), shared);
     // Reconstruct the body: structured control flow recovered from the graph.
@@ -2876,7 +2918,7 @@ function entryPointSeg(t, scope, ipdom, ctx) {
                         : (() => {
                             if (ctx.o.bestEffort === false)
                                 throw new Error(`decompile: unsupported entry-point trigger type "${t.type}".`);
-                            return `${ctx.imp.use('manual')}() /* TODO: unsupported trigger type ${t.type} */`;
+                            return `${ctx.imp.use('manual')}() /* TODO: unsupported trigger type ${commentText(t.type)} */`;
                         })();
     const scoped = readFlowGlobals(ctx.flow.variables, runStrict)
         .filter((g) => g.direction === 'in' && g.triggerNodeId === t.id);
@@ -2885,9 +2927,7 @@ function entryPointSeg(t, scope, ipdom, ctx) {
         const sharedOf = (g) => ctx.shared?.byInput.get(`${t.id}\0${g.id}`);
         optParts.push(`inputs: { ${scoped.map((g) => `${key(g.name ?? g.id)}: ${declExpr(g, true, ctx.imp, sharedOf(g))}`).join(', ')} }`);
     }
-    const ver = verClause(t);
-    if (ver)
-        optParts.push(ver);
+    optParts.push(...triggerOptParts(t));
     const first = scopeSucc(ctx.graph, t.id, scope)[0];
     const prefixSegs = first !== undefined ? region(first, EXIT, scope, ipdom, ctx) : [];
     const optArgText = optParts.length ? `, { ${optParts.join(', ')} }` : (prefixSegs.length ? ', undefined' : '');

package/dist/emit.js

@@ -25,13 +25,14 @@
  * are the ones `.build()` and `serialize()` raise themselves. Callers who want
  * the static pass should call `check()` — or use `compile-cli`.
  */
-import { writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { serialize } from './serialize.js';
 import { Library } from './library.js';
 import { Bindings } from './bindings.js';
 import { resolveLibraryDir } from './core/library-cache.js';
 import { defaultBindingsFile } from './workdir.js';
+import { writeJsonFile } from './core/json-file.js';
 /**
  * Resolve the connector library the same way `compile-cli` does: only load it
  * when it is actually there, so a flow with no connectors emits fine without a
@@ -51,11 +52,11 @@ export function emitFlow(built, path, opts = {}) {
         library: opts.library ?? defaultLibrary(opts.libraryDir),
         bindings: opts.bindings ?? new Bindings(bindFile),
         // Same channel `compile` uses; a host that wants them elsewhere passes `warn`.
-        warn: opts.warn ?? ((w) => console.error(`  ⚠ [${w.code}] ${w.message}`)),
+        warn: opts.warn ?? ((w) => process.stderr.write(`  ⚠ [${w.code}] ${w.message}\n`)),
     });
     const dir = dirname(path);
     if (dir && dir !== '.' && !existsSync(dir))
         mkdirSync(dir, { recursive: true });
-    writeFileSync(path, JSON.stringify(flowJson, null, 2) + '\n');
+    writeJsonFile(path, flowJson);
     return flowJson;
 }