@uipath/maestro-builder-sdk 6.20.5 → 6.21.0

package/dist/check.js

@@ -11,14 +11,13 @@ import { planContributionBindings } from './core/contribution-bindings.js';
 import { definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
 import { actionVersion, bundledActionNodeType, bundledDefinition, perCallDefinition, resolveContributionDefinition } from './serialize.js';
 import { sdkFormFieldType } from './core/form-field-type.js';
-import { QUEUE_ITEM_RECORD_SCHEMA } from './core/queue-record.js';
 import { AGENTIC_PROCESS_FORMS } from './core/agentic-process-forms.js';
 import { checkEventResolution, checkEventSubscription, eventParamsFor, } from './core/event-checks.js';
 import { checkCookedEscapes } from './flow-expr-check.js';
 import { FLOW_EXPR_DIALECT, checkBindingLabels, checkBindingPresence, checkConnectorContract as coreCheckConnectorContract, checkConnectorLookups as coreCheckConnectorLookups, checkConnectorSchema as coreCheckConnectorSchema, collectConnectionUses, connectionConnectorConflicts, } from './core/connector-checks.js';
 import { prepareCommand } from './core/cli-spelling.js';
 import { commentText } from './core/comment-text.js';
-import { editDistance } from './core/edit-distance.js';
+import { nearestName } from './core/edit-distance.js';
 import { isAnswerField } from './core/hitl-answers.js';
 import { hitlDerivesOutcomeHandles, hitlExitModel, hitlRoutesPerOutcome, outcomeIdOf } from './core/hitl-routing.js';
 import { declaredExits, hasExits } from './core/step-ports.js';
@@ -26,6 +25,7 @@ import { stopsAtEnd } from './flow-step-tree.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { compareSchemaVersions, schemaVersionRefusal } from './schema-version.js';
 import { planFlowGlobals, planSharedInputs, sharedInputRoots } from './flow-variables.js';
+import { planOutputBacking } from './flow-output-backing.js';
 import { ownEntry } from './core/own-entry.js';
 import { FLOW_NODE_TYPES } from './flow-node-registry.js';
 import { resolveVersion } from './core/nodes/versioned.js';
@@ -498,8 +498,6 @@ function checkFlow(built, ancestors, opts = {}) {
                 if (s.spec.kind === 'inlineAgent') {
                     checkInlineAgent(s.name, s.spec.inputs, diags, opts);
                 }
-                if (s.spec.kind === 'queueItem')
-                    checkQueueItem(s.name, s.spec.inputs, diags);
                 {
                     const rule = OUTPUT_READ_RULES[s.spec.kind];
                     if (typeof rule === 'function') {
@@ -1176,6 +1174,22 @@ function checkFlow(built, ancestors, opts = {}) {
                 readOutput(field, rest, step, diags);
                 continue;
             }
+            // A registered node type that states its output's fields: the same read
+            // rule, worded by its contract and reported through its family's catalog.
+            const fieldsPlaced = registeredSteps.get(name);
+            const fieldsContract = fieldsPlaced?.impl.output(fieldsPlaced.spec);
+            if (fieldsPlaced && fieldsContract?.kind === 'fields') {
+                const found = [];
+                checkDeclaredOutputRead({
+                    prefix: fieldsContract.read.codePrefix, what: fieldsContract.read.label, name, field, rest, step,
+                    diags: found, withoutReturns: fieldsContract.read.whenUndeclared,
+                    declared: fieldsContract.fields === undefined ? undefined : Object.keys(fieldsContract.fields),
+                    open: fieldsContract.open,
+                });
+                for (const d of found)
+                    diags.push(catalogued(fieldsPlaced.entry, step, d.code, d.message, d.suggestion));
+                continue;
+            }
             // A loop step exposes a fixed set of fields, and only those resolve at run
             // time — `$vars.<loop>.item` reads undefined rather than the iteration
             // item. Catch the wrong spelling here, in the fast loop.
@@ -1302,8 +1316,9 @@ function checkLoopListEnvelope(loop, connectors, opts, diags) {
  * it never rejoins the main path, and when it runs out of steps `emitPortList`
  * gives it an End of its own. `writtenTails` collects those bodies' tails.
  *
- * Every such End maps every output from its own variable
- * (`result <- $vars.result`), the same as a `.return()` that names no value.
+ * Every such End maps every output from what set it on the way (its backing
+ * Variable, `result <- $vars.resultValue`, #1092), or `null` when nothing could,
+ * the same as a `.return()` that names no value.
  * That loses nothing when the flow declares no outputs, or when each output
  * was set on the way: by a `default`, a `{ shared }` input that every root
  * feeds, or `{ updates }` on a step of that path. One warning per End: it
@@ -1456,32 +1471,6 @@ function surelyWritten(tails) {
         return new Set();
     return new Set([...tails[0].written].filter((n) => tails.every((t) => t.written.has(n))));
 }
-/**
- * Closest of `candidates` to `name`: same word ignoring case, one contained in
- * the other, or within two edits (`txt` → `text`, `reveresed` → `reversed`).
- *
- * The suggestion is the whole value of these diagnostics — a subflow's input and
- * output names are the child's, so the author is typing them from memory.
- */
-function nearestName(name, candidates) {
-    const lk = name.toLowerCase();
-    const exact = candidates.find((c) => c.toLowerCase() === lk);
-    if (exact)
-        return exact;
-    const contained = candidates.find((c) => c.toLowerCase().includes(lk) || lk.includes(c.toLowerCase()));
-    if (contained)
-        return contained;
-    let best;
-    let bestD = 3;
-    for (const c of candidates) {
-        const d = editDistance(lk, c.toLowerCase());
-        if (d < bestD) {
-            bestD = d;
-            best = c;
-        }
-    }
-    return best;
-}
 /**
  * Diagnose a `subflow` step: the child flow itself, and the parent→child
  * binding.
@@ -1778,7 +1767,17 @@ function checkGlobalNames(built, diags) {
         diags.push({ level: p.level, code: p.code, message: p.message, ...(p.suggestion ? { suggestion: p.suggestion } : {}) });
     }
     const vars = [...(built.vars ?? []), ...shared.autoVars];
-    for (const p of planFlowGlobals({ inputs: built.inputs ?? [], outputs: built.outputs ?? [], vars }).problems) {
+    const plan = planFlowGlobals({ inputs: built.inputs ?? [], outputs: built.outputs ?? [], vars });
+    for (const p of plan.problems) {
+        diags.push({ level: 'error', code: p.code, message: p.message, ...(p.suggestion ? { suggestion: p.suggestion } : {}) });
+    }
+    if (plan.problems.length)
+        return;
+    // An output the flow sets from inside is emitted with an `inout` Variable
+    // `<output>Value` behind it (#1092); that id must be free. Same plan as
+    // `emittableGlobals`, so a name check passes is one serialize can emit.
+    const sharedOutputs = new Set(shared.targets.filter((t) => t.declaredAs === 'output').map((t) => t.name));
+    for (const p of planOutputBacking(built, plan.outputs, plan.vars, sharedOutputs).problems) {
         diags.push({ level: 'error', code: p.code, message: p.message, ...(p.suggestion ? { suggestion: p.suggestion } : {}) });
     }
 }
@@ -2528,7 +2527,7 @@ function checkDeclaredOutputRead(o) {
         return;
     }
     const wanted = (rest ?? '').replace(/^\./, '').split('.')[0];
-    if (!wanted)
+    if (!wanted || o.open)
         return;
     if (o.declared === undefined) {
         diags.push({
@@ -2560,23 +2559,6 @@ function checkRpaWorkflowRead(name, field, rest, spec, step, diags) {
             + `synthesizes for it.`,
     });
 }
-/**
- * A queue step publishes one of two shapes: a plain enqueue publishes the queue
- * ITEM's Orchestrator record (fixed, declared by the serializer from
- * `QUEUE_ITEM_RECORD_SCHEMA`), a `wait: true` publishes the processed result,
- * whose fields only the author's `returns` states.
- */
-function checkQueueItemRead(name, field, rest, spec, step, diags) {
-    const waitReturns = Object.keys(spec?.returns ?? {});
-    checkDeclaredOutputRead({
-        prefix: 'QUEUE', what: spec?.wait ? 'Queue wait' : 'Queue item', name, field, rest, step, diags,
-        declared: !spec?.wait
-            ? Object.keys(QUEUE_ITEM_RECORD_SCHEMA.properties)
-            : waitReturns.length ? waitReturns : undefined,
-        withoutReturns: `What the consumer writes into the processed item's result is that automation's business; `
-            + `declare the fields you read.`,
-    });
-}
 /**
  * THE GATE (flow-builder-sdk#850). Each `returns`-bearing kind maps to the rule
  * that checks a read of its output, or to a stated reason it has none.
@@ -2597,7 +2579,7 @@ const OUTPUT_READ_RULES = {
     agenticProcess: checkAgenticProcessRead,
     agent: checkAgentRead,
     inlineAgent: checkInlineAgentRead,
-    queueItem: checkQueueItemRead,
+    queueItem: { exempt: 'Registered: its node type states the fields a read may name (nodes/queue/flow/, a `fields` output contract).' },
     script: {
         exempt: 'Not yet: only the field-map form of a script\'s `returns` gives a list to check against (the '
             + 'type form and the inferred form do not), and script is the most-used step, so its rule lands with '
@@ -3620,31 +3602,6 @@ function checkInlineAgentRead(name, field, rest, spec, step, diags) {
         ...(nearest ? { suggestion: `out('${name}', '${nearest}')` } : {}),
     });
 }
-/**
- * Check a `queueItem(...)` call.
- *
- * WHAT THESE RULES CAN AND CANNOT SEE. Whether the queue exists, whether anything
- * drains it, and what a consumer writes into a processed item's result all live on
- * the tenant. So these cover the mistakes decidable from the call — plus the one
- * mistake the PLATFORM decides and rejects at run time, which is worth catching
- * here because its error arrives from Orchestrator as an HTTP 400 three layers
- * away:
- *
- *  - a missing/blank `queue`, `folderPath` or `key`. Without the first two
- *    nothing can resolve the node's `resourceBindings.name`, and without `key`
- *    nothing joins the node to its bindings — both read as engine errors rather
- *    than authoring ones.
- *  - a `key` that is not a GUID. The commonest form is passing the queue's NAME
- *    where its Orchestrator key belongs.
- *  - a NESTED `item`. Orchestrator answers "Property values must be simple (like
- *    numbers or text) and not complex or composite data types (like objects or
- *    arrays)" — a run-time 400 for something visible in the source.
- *  - a `priority` outside the three the node type offers. The platform normalizes
- *    an unknown one silently, so it is a wrong RESULT, not an error.
- *  - `returns` on a step that does not wait (there is nothing per-tenant to
- *    declare), and a `wait: true` step whose result nothing can read.
- *  - a non-ISO `dueDate` / `deferDate`.
- */
 /**
  * The five forbidden inputs on an IxP node. They belonged to a prior schema and
  * v1's own authoring reference calls them "the most common training-data-recall
@@ -3715,89 +3672,6 @@ function checkIxpExtract(step, inputs, diags) {
         }
     }
 }
-function checkQueueItem(step, inputs, diags) {
-    const at = (code, message, suggestion) => {
-        diags.push({ level: 'error', code, message, step, ...(suggestion ? { suggestion } : {}) });
-    };
-    const warn = (code, message, suggestion) => {
-        diags.push({ level: 'warning', code, message, step, ...(suggestion ? { suggestion } : {}) });
-    };
-    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
-    if (blank(inputs?.queue)) {
-        at('QUEUE_NO_NAME', `Queue step "${step}" has no \`queue\`. That is the queue's name in Orchestrator, and the `
-            + `runtime resolves the queue by name + folder — without it the run fails before dispatch.`, `queue: 'SupplierInvoices'`);
-    }
-    if (blank(inputs?.folderPath)) {
-        at('QUEUE_NO_FOLDER', `Queue step "${step}" has no \`folderPath\`. Queues are folder-scoped, and the runtime `
-            + `resolves this one by name + folder.`, `folderPath: 'Shared'`);
-    }
-    if (blank(inputs?.key)) {
-        at('QUEUE_NO_KEY', `Queue step "${step}" has no \`key\`. That is the queue's own Orchestrator key, and it is `
-            + `what joins this node to the flow's queue bindings — without it nothing says which `
-            + `bindings belong to the node, so it cannot be dispatched. Find it with `
-            + `\`uip or queues list --all-folders\`.`, `key: 'fa1a7328-cd17-4525-b5ab-29d86e399312'`);
-    }
-    else if (!GUID_RE.test(String(inputs.key).trim())) {
-        at('QUEUE_KEY_NOT_GUID', `Queue step "${step}"'s \`key\` is ${JSON.stringify(inputs.key)}, which is not an `
-            + `Orchestrator key. \`key\` is the GUID the tenant gives the queue; the queue's NAME goes `
-            + `in \`queue\` and its folder in \`folderPath\`.`, `key: '<guid>', queue: ${JSON.stringify(inputs.key)}`);
-    }
-    // The item's data must be FLAT. This is the platform's rule, not ours, and it is
-    // enforced at the far end: a nested value earns an HTTP 400 from Orchestrator
-    // mid-run, which is a long way from the line that caused it.
-    const item = inputs?.item;
-    if (item === undefined || item === null) {
-        warn('QUEUE_NO_ITEM', `Queue step "${step}" has no \`item\`, so it enqueues an item with no data. That is legal `
-            + `— a bare item with a reference is a real pattern — but if the work needs a payload, this `
-            + `is where it goes.`, `item: { InvoiceId: input('invoiceRef') }`);
-    }
-    else if (typeof item !== 'object' || Array.isArray(item)) {
-        at('QUEUE_ITEM_NOT_OBJECT', `Queue step "${step}"'s \`item\` is ${Array.isArray(item) ? 'an array' : typeof item}. It `
-            + `must be an object of field names to primitive values — that object becomes the queue `
-            + `item's \`SpecificContent\`.`, `item: { InvoiceId: 'INV-1', Amount: 120 }`);
-    }
-    else {
-        for (const [k, v] of Object.entries(item)) {
-            // An Expr is a reference the runtime resolves — its VALUE may be anything,
-            // and nothing local can know, so it is not flagged here.
-            if (v instanceof Expr)
-                continue;
-            if (v !== null && typeof v === 'object') {
-                at('QUEUE_ITEM_FIELD_NOT_PRIMITIVE', `Queue step "${step}"'s \`item.${k}\` is ${Array.isArray(v) ? 'an array' : 'an object'}. `
-                    + `Orchestrator rejects a queue item whose property values are not simple: `
-                    + `"Property values must be simple (like numbers or text) and not complex or composite `
-                    + `data types (like objects or arrays)". Flatten it, or JSON-encode it into one string `
-                    + `field.`, `item: { ${k}: JSON.stringify(...) }  // or ${commentText(k)}Id, ${commentText(k)}Name, …`);
-            }
-        }
-    }
-    if (inputs?.priority !== undefined && !QUEUE_PRIORITIES.includes(String(inputs.priority))) {
-        at('QUEUE_BAD_PRIORITY', `Queue step "${step}"'s \`priority\` is ${JSON.stringify(inputs.priority)}. The node type `
-            + `offers exactly ${QUEUE_PRIORITIES.map((p) => `"${p}"`).join(', ')} — anything else is `
-            + `normalized silently by the platform, so the item is enqueued at the wrong priority `
-            + `rather than rejected.`, `priority: '${nearestName(String(inputs.priority), QUEUE_PRIORITIES) ?? 'Normal'}'`);
-    }
-    for (const field of ['deferDate', 'dueDate']) {
-        const v = inputs?.[field];
-        if (typeof v === 'string' && v.trim() !== '' && Number.isNaN(Date.parse(v))) {
-            at('QUEUE_BAD_DATE', `Queue step "${step}"'s \`${field}\` is ${JSON.stringify(v)}, which is not a date `
-                + `Orchestrator can read. It takes ISO-8601 — a full timestamp with a zone.`, `${field}: '2026-08-05T17:00:00Z'`);
-        }
-    }
-    // `returns` describes what a CONSUMER produced, which only exists if the step
-    // waited for one. On a fire-and-forget enqueue it is a misunderstanding worth
-    // naming: the output is the queue item's own record, and the serializer already
-    // declares its fields.
-    if (!inputs?.wait && inputs?.returns && Object.keys(inputs.returns).length) {
-        warn('QUEUE_RETURNS_WITHOUT_WAIT', `Queue step "${step}" declares \`returns\` but does not \`wait\`, so nothing produces those `
-            + `fields: a fire-and-forget enqueue publishes the queue ITEM's own Orchestrator record `
-            + `(\`Key\`, \`Status\`, \`Reference\`, \`SpecificContent\`, …), whose fields are already `
-            + `declared for you. \`returns\` describes what a CONSUMER wrote into a processed item's `
-            + `result, which needs \`wait: true\`.`, `wait: true`);
-    }
-}
-/** The three priorities `core.action.queue.create[-and-wait]`'s form offers. */
-const QUEUE_PRIORITIES = ['Low', 'Normal', 'High'];
 /** Best guess at what the author meant, for a `SCHEDULE_NOT_ISO` suggestion. */
 function nearestInterval(every) {
     // By far the likeliest slip: a correct duration missing the "R/" repeat marker.

package/dist/core/actions.d.ts

@@ -1916,82 +1916,6 @@ export interface ContextIndexRef {
     /** Restrict to one file type; `'All'` (the platform's default) or e.g. `'pdf'`. */
     fileExtension?: string;
 }
-/** The three priorities an Orchestrator queue item can carry. */
-export type QueuePriority = 'Low' | 'Normal' | 'High';
-export interface QueueItemInputs {
-    /** The queue's name in Orchestrator — e.g. `'SupplierInvoices'`. */
-    queue: string;
-    /** The Orchestrator folder holding the queue — e.g. `'Shared'`. */
-    folderPath: string;
-    /**
-     * The queue's own Orchestrator key (a GUID). It is the JOIN between this node
-     * and the flow's queue bindings — a node which does not reference its bindings
-     * cannot be dispatched — and it is what
-     * the designer's queue picker writes. The RUNTIME resolves the queue by
-     * `queue` + `folderPath`, so all three are needed and none is redundant.
-     *
-     * Find it with `uip or queues list --all-folders`.
-     */
-    key: string;
-    /**
-     * The work item's own data: a FLAT object of primitive values. It becomes the
-     * item's `SpecificContent`, and Orchestrator rejects a nested object or array
-     * with "Property values must be simple (like numbers or text)".
-     */
-    item: Record<string, unknown>;
-    /** Processing priority. Defaults to `'Normal'`, as the node type does. */
-    priority?: QueuePriority;
-    /**
-     * A reference string for the item. Optional in general — but a queue created
-     * with "enforce unique reference" REQUIRES one and rejects a repeat with
-     * `HTTP 409: Duplicate Reference`, so derive it from the flow's input rather
-     * than hard-coding it.
-     *
-     * Which is why it takes an {@link Expr} as well as a literal: the serializer
-     * renders it through the same path as any other value, so
-     * `reference: input('invoiceRef')` and
-     * ``reference: js`${input('invoiceRef')} + "-review"` `` both emit. Typing it
-     * as a bare `string` contradicted the advice directly above and stopped two
-     * of the SDK's own examples compiling.
-     */
-    reference?: string | Expr;
-    /** Earliest the item may be processed, ISO-8601 (e.g. `'2026-08-01T09:00:00Z'`). */
-    deferDate?: string;
-    /** Latest the item should be processed, ISO-8601. What an SLA is measured against. */
-    dueDate?: string;
-    /**
-     * `false` (the default) enqueues and moves on — `core.action.queue.create`.
-     * `true` PARKS the flow until whatever consumes the queue has processed the
-     * item, and publishes that result — `core.action.queue.create-and-wait`.
-     *
-     * The two are one construct with two data paths, so this is one field rather
-     * than two factories. Waiting is not free: nothing completes the item but a
-     * consumer (an RPA process bound to the queue), so a flow that waits on a queue
-     * nobody drains waits forever.
-     */
-    wait?: boolean;
-    /**
-     * Only for `wait: true`: the fields the PROCESSED item's result carries, and
-     * their types (e.g. `{ approved: 'boolean' }`). Required if anything reads the
-     * step's output.
-     *
-     * Why you have to say: what a consumer writes into a transaction's `Output` is
-     * that automation's business, not the queue's — no definition declares it and
-     * authoring happens offline. Without it `$vars.<step>.output.<field>` reads from
-     * an object with no declared fields, and nothing could tell a real field from
-     * a typo.
-     *
-     * `wait: false` needs none: what it publishes is the queue ITEM's own
-     * Orchestrator record (`Key`, `Status`, `Reference`, `SpecificContent`, …),
-     * which is the same for every queue, so the serializer declares it for you.
-     *
-     * @enforcedBy QUEUE_READ_UNKNOWN_FIELD A read must name a field of the record
-     * (`wait: false`) or of this `returns` (`wait: true`).
-     * @enforcedBy QUEUE_READ_WITHOUT_RETURNS Reading a field off a `wait: true` result
-     * requires declaring it here.
-     */
-    returns?: Record<string, ReturnFieldType>;
-}
 /**
  * Every action kind, keyed by kind, to the body of its spec — the arm's fields
  * other than `kind`. {@link ActionSpec} is built from it.
@@ -2064,10 +1988,6 @@ export interface FlowActionSpecs {
     inlineAgent: {
         inputs: InlineAgentInputs;
     };
-    /** The spec {@link queueItem} builds. */
-    queueItem: {
-        inputs: QueueItemInputs;
-    };
     /** The spec {@link summarize} builds. */
     summarize: {
         inputs: SummarizeInputs;
@@ -2713,52 +2633,6 @@ export declare function agent(inputs: AgentInputs): ActionSpec;
  * @returns An action spec to pass to `.step(name, …)`.
  */
 export declare function inlineAgent(inputs: InlineAgentInputs): ActionSpec;
-/**
- * Declare an Orchestrator QUEUE ITEM step.
- *
- * @remarks
- * A queue is Orchestrator's work list: something puts items on it, and an
- * automation bound to the queue takes them off one at a time. This step is the
- * putting-on half.
- *
- * `queue` + `folderPath` are what the runtime resolves the queue by, and `key` is
- * the queue's own Orchestrator key: it joins this node to the flow's queue
- * bindings, which the serializer emits and points the node at. All three, for the
- * same reason `rpaWorkflow` takes three — the key is the AUTHORING identity, the
- * two bindings are the RUNTIME one.
- *
- * `item` is the work item's data. It becomes the item's `SpecificContent`, and it
- * must be FLAT: Orchestrator rejects a nested object or array outright.
- *
- * **`wait`** picks between the family's two node types, which are one construct
- * with two data paths. Default `false` enqueues and moves on, publishing the queue
- * item's own Orchestrator record — read a field with `out('<step>', 'Key')`, and
- * nothing extra has to be declared because that record's shape is the same for
- * every queue. `wait: true` PARKS the flow until the item has been processed and
- * publishes the consumer's result instead, which is per-automation — so a read of
- * it needs `returns`, exactly as an rpa process's output does.
- *
- * What no rung can tell you: whether anything actually drains this queue. A
- * `wait: true` step on a queue with no consumer waits until it times out.
- *
- * @example
- * **Enqueue a work item and read its Orchestrator key**
- * ```ts
- * .step('enqueue', queueItem({
- *   queue: 'SupplierInvoices',
- *   folderPath: 'Shared',
- *   key: 'fa1a7328-cd17-4525-b5ab-29d86e399312',
- *   item: { InvoiceId: input('invoiceRef'), Amount: input('amount') },
- *   reference: 'INV-2031',
- * }))
- * .return({ itemKey: out('enqueue', 'Key') })
- * ```
- *
- * @param inputs - The `queue` and `folderPath`, the `item` to add, and whether
- * to `wait` for it to be processed.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export declare function queueItem(inputs: QueueItemInputs): ActionSpec;
 /**
  * Declare an Integration Service connector action — the typed form, where a
  * generated descriptor supplies the nodeType and statically-checked input types:

package/dist/core/actions.js

@@ -711,54 +711,6 @@ export function agent(inputs) {
 export function inlineAgent(inputs) {
     return builtinActionSpec({ kind: 'inlineAgent', inputs });
 }
-/**
- * Declare an Orchestrator QUEUE ITEM step.
- *
- * @remarks
- * A queue is Orchestrator's work list: something puts items on it, and an
- * automation bound to the queue takes them off one at a time. This step is the
- * putting-on half.
- *
- * `queue` + `folderPath` are what the runtime resolves the queue by, and `key` is
- * the queue's own Orchestrator key: it joins this node to the flow's queue
- * bindings, which the serializer emits and points the node at. All three, for the
- * same reason `rpaWorkflow` takes three — the key is the AUTHORING identity, the
- * two bindings are the RUNTIME one.
- *
- * `item` is the work item's data. It becomes the item's `SpecificContent`, and it
- * must be FLAT: Orchestrator rejects a nested object or array outright.
- *
- * **`wait`** picks between the family's two node types, which are one construct
- * with two data paths. Default `false` enqueues and moves on, publishing the queue
- * item's own Orchestrator record — read a field with `out('<step>', 'Key')`, and
- * nothing extra has to be declared because that record's shape is the same for
- * every queue. `wait: true` PARKS the flow until the item has been processed and
- * publishes the consumer's result instead, which is per-automation — so a read of
- * it needs `returns`, exactly as an rpa process's output does.
- *
- * What no rung can tell you: whether anything actually drains this queue. A
- * `wait: true` step on a queue with no consumer waits until it times out.
- *
- * @example
- * **Enqueue a work item and read its Orchestrator key**
- * ```ts
- * .step('enqueue', queueItem({
- *   queue: 'SupplierInvoices',
- *   folderPath: 'Shared',
- *   key: 'fa1a7328-cd17-4525-b5ab-29d86e399312',
- *   item: { InvoiceId: input('invoiceRef'), Amount: input('amount') },
- *   reference: 'INV-2031',
- * }))
- * .return({ itemKey: out('enqueue', 'Key') })
- * ```
- *
- * @param inputs - The `queue` and `folderPath`, the `item` to add, and whether
- * to `wait` for it to be processed.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function queueItem(inputs) {
-    return builtinActionSpec({ kind: 'queueItem', inputs });
-}
 export function connector(a, b, c, d) {
     if (typeof a === 'string') {
         const opts = (d ?? {});

package/dist/core/edit-distance.d.ts

@@ -8,3 +8,11 @@
  */
 /** Levenshtein distance, two rows. Short strings only (names and ids). */
 export declare function editDistance(a: string, b: string): number;
+/**
+ * Closest of `candidates` to `name`: same word ignoring case, one contained in
+ * the other, or within two edits (`txt` → `text`, `reveresed` → `reversed`).
+ *
+ * Shared by Flow's `check` and the node families' rules, so a family's
+ * suggestion matches the pipeline's.
+ */
+export declare function nearestName(name: string, candidates: string[]): string | undefined;

package/dist/core/edit-distance.js

@@ -18,3 +18,29 @@ export function editDistance(a, b) {
     }
     return prev[b.length];
 }
+/**
+ * Closest of `candidates` to `name`: same word ignoring case, one contained in
+ * the other, or within two edits (`txt` → `text`, `reveresed` → `reversed`).
+ *
+ * Shared by Flow's `check` and the node families' rules, so a family's
+ * suggestion matches the pipeline's.
+ */
+export function nearestName(name, candidates) {
+    const lk = name.toLowerCase();
+    const exact = candidates.find((c) => c.toLowerCase() === lk);
+    if (exact)
+        return exact;
+    const contained = candidates.find((c) => c.toLowerCase().includes(lk) || lk.includes(c.toLowerCase()));
+    if (contained)
+        return contained;
+    let best;
+    let bestD = 3;
+    for (const c of candidates) {
+        const d = editDistance(lk, c.toLowerCase());
+        if (d < bestD) {
+            bestD = d;
+            best = c;
+        }
+    }
+    return best;
+}

package/dist/core/js-code-spans.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The parts of a JavaScript expression or script body that are code.
+ *
+ * Short version: `$vars.summary` inside a quoted string is text, not a read.
+ * A rewrite that renames `$vars.<name>` (a step's node id, an output's backing
+ * Variable, #1092) must leave string literals, comments and regex literals
+ * alone, or it changes what the flow does:
+ *
+ * ```js
+ * return "$vars.summary" + $vars.summary;
+ * //     ^^^^^^^^^^^^^^^ text: kept    ^^^^^^^^^^^^^ code: renamed
+ * ```
+ *
+ * A template literal's text is kept too, and its `${…}` holes are code.
+ *
+ * This is a scanner, not a parser. It tells a regex literal from a division by
+ * the character before the `/` (the usual heuristic), so `return /"/` is read
+ * as a division. Nothing in a flow's expressions depends on that case.
+ */
+/**
+ * `text` with `fn` applied to each run of code, and every string, template
+ * text, comment and regex literal copied as written.
+ */
+export declare function mapJsCode(text: string, fn: (code: string) => string): string;