@uipath/maestro-builder-sdk 6.20.6 → 6.21.1

package/dist/check.js

@@ -9,16 +9,15 @@ import { Expr, SCHEDULE_PRESETS, parseIxpProjectType, flatNameOf, flatNameSegmen
 import { FlowNode } from './core/node-classes.js';
 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 { actionVersion, bundledActionNodeType, bundledContainerDefinition, 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';
@@ -499,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') {
@@ -1177,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.
@@ -1458,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.
@@ -2540,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({
@@ -2572,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.
@@ -2609,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 '
@@ -3632,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
@@ -3727,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.
@@ -5020,19 +4882,22 @@ placed) {
     // source here means a hand-built `BuiltFlow`; there is nothing to say about it.
     if (!step)
         return;
-    // A `.loop()` CONTAINER is fine: `core.logic.loop` declares the error handle at
-    // both bundled versions, and a measured run routed a body failure to it — the
-    // container's envelope carried the body's message in `detail` and the failing
-    // body step's label in `element`.
-    if (step.kind === 'loop')
-        return;
-    // `.doWhile()` is not. `core.logic.dowhile@1.0` declares an error VARIABLE and
-    // no error HANDLE, so the edge would leave a handle the node does not have —
-    // the shape that fails product validate with "the current manifest does not
-    // declare that handle". The builder refuses this too; this catches a
-    // hand-built flow and says the same thing.
-    if (step.kind === 'doWhile') {
-        diags.push(doWhileOnErrorRefusal(step.name));
+    // A container (`.loop()` / `.doWhile()`) is decided by its bundled definition
+    // too. Both set `supportsErrorHandling: true`, and both route a body failure
+    // to the container's port, measured: the container's envelope carries the
+    // body's message in `detail` and the failing body step's canvas label (its id when it has no `label`) in `element`, and
+    // the instance completes. `core.logic.dowhile@1.0` declares no `error` handle,
+    // but the flag alone grants it: flow validate adds the handle from the flag.
+    if (step.kind === 'loop' || step.kind === 'doWhile') {
+        const def = bundledContainerDefinition(step.kind, step.options?.version);
+        if (def === undefined || definitionHasErrorPort(def))
+            return;
+        diags.push({
+            level: 'error',
+            code: 'ONERROR_NO_ERROR_PORT',
+            message: errorPortRefusal(step.name, def),
+            step: step.name,
+        });
         return;
     }
     // A custom FlowAction or rawNode has no `kind`: ask its DEFINITION, with the
@@ -5050,10 +4915,6 @@ placed) {
         }
         // A custom node backed by a typed family's bundled definition gets that
         // family's refusals: the rules are about the node type, not the SDK kind.
-        if (def?.nodeType === 'core.logic.dowhile') {
-            diags.push(doWhileOnErrorRefusal(step.name));
-            return;
-        }
         if (def?.nodeType === 'core.action.http') {
             diags.push(plainHttpOnErrorRefusal(step.name));
             return;
@@ -5158,17 +5019,6 @@ placed) {
     if (spec.kind === 'http' && !spec.inputs?.managed)
         diags.push(plainHttpOnErrorRefusal(step.name));
 }
-/** `.onError` after a `core.logic.dowhile` container: it declares no error handle. */
-function doWhileOnErrorRefusal(stepName) {
-    return {
-        level: 'error',
-        code: 'ONERROR_NO_ERROR_PORT',
-        message: `Step "${stepName}" is a .doWhile() container. It declares an error variable but no error HANDLE `
-            + `(core.logic.dowhile@1.0: input, success, start, continue, break), so the edge would leave a handle the `
-            + `node does not have. Handle the failure inside the body, on the step that can fail.`,
-        step: stepName,
-    };
-}
 /** `.onError` after a plain `core.action.http` node (see the two measured facts in {@link checkOnError}). */
 function plainHttpOnErrorRefusal(stepName) {
     return {

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/nodes/node-type.d.ts

@@ -45,12 +45,26 @@ export interface OutputRead {
     /** The step whose expression contains the read. */
     reader: string;
 }
+/**
+ * How the artifact words a read of a `fields` output: the code prefix its read
+ * diagnostics share (`<PREFIX>_READ_NOT_OUTPUT`, `_READ_WITHOUT_RETURNS`,
+ * `_READ_UNKNOWN_FIELD`, each in the family's catalog), how a message names the
+ * node (`'Queue item'`), and what to tell an author who declared no fields.
+ */
+export interface FieldsRead {
+    readonly codePrefix: string;
+    readonly label: string;
+    readonly whenUndeclared: string;
+}
 /**
  * What reading a node's output yields at run time.
  *
  * `none` keeps the diagnostic code of the rule it replaces
  * (`DATAFABRIC_DELETE_HAS_NO_OUTPUT`, `MOCK_HAS_NO_OUTPUT`, …) and builds the
- * message itself, so a port changes no diagnostic an author sees.
+ * message itself, so a port changes no diagnostic an author sees. `fields`
+ * states the fields a read may name — `undefined` when the author declared none,
+ * which makes any field read its own mistake — and `read` keeps the wording of
+ * the read rule it replaces, for the same reason. `open` admits any field.
  */
 export type OutputContract = {
     readonly kind: 'none';
@@ -58,8 +72,9 @@ export type OutputContract = {
     message(read: OutputRead): string;
 } | {
     readonly kind: 'fields';
-    readonly fields: Readonly<Record<string, TypeDesc>>;
+    readonly fields: Readonly<Record<string, TypeDesc>> | undefined;
     readonly open?: boolean;
+    readonly read: FieldsRead;
 } | {
     readonly kind: 'opaque';
 };

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

@@ -23,8 +23,6 @@ import { ownEntry } from './own-entry.js';
 export const TYPED_FACTORIES = {
     'core.action.http': { factory: 'http({ managed: false })' },
     'core.action.http.v2': { factory: 'http({ managed: true })' },
-    'core.action.queue.create': { factory: 'queueItem()' },
-    'core.action.queue.create-and-wait': { factory: 'queueItem({ wait: true })' },
     'core.control.end': { factory: '.return()' },
     'core.logic.decision': { factory: '.branch()' },
     'core.logic.dowhile': { factory: '.doWhile(name, condition, body, { limit, breakEnabled })' },

package/dist/decompile.js

@@ -228,8 +228,6 @@ const T = {
     hitlQuickForm: 'uipath.human-in-the-loop.quick-form',
     hitlActionApp: 'uipath.human-in-the-loop.coded-action-app',
     hitlDocValidation: 'uipath.human-in-the-loop.document-validation',
-    queueCreate: 'core.action.queue.create',
-    queueCreateAndWait: 'core.action.queue.create-and-wait',
     summarize: 'uipath.pattern.deep-rag',
     batchTransform: 'uipath.pattern.batch-transform',
     sendMessage: 'uipath.conversational.send-message',
@@ -644,35 +642,6 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
         case T.hitlActionApp:
         case T.hitlDocValidation:
             return emitHitl(node, imp, inputNames, graph);
-        case T.queueCreate:
-        case T.queueCreateAndWait: {
-            // `itemData` is the node's name for the surface's `item` (the reference
-            // documents the mapping); `queue` carries the three identity fields.
-            const q = (inputs.queue ?? {});
-            const rows = Object.entries((inputs.itemData ?? {}))
-                .map(([k, v]) => [k, emitVal(v, imp, inputNames)]);
-            const optStr = (key) => {
-                const raw = unwrapSource(inputs[key]);
-                // serialize writes '' for an omitted optional — that is not an authored
-                // value, so it must not come back as one.
-                if (raw === undefined || raw === '')
-                    return undefined;
-                return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames) : tsLiteral(raw);
-            };
-            const priority = unwrapPlain(inputs.priority);
-            return `${imp.use('queueItem')}(${opts([
-                ['queue', tsText(q.name)],
-                ['folderPath', tsText(q.folderPath)],
-                ['key', tsText(q.key)],
-                ['item', rows.length ? objLit(rows) : '{}'],
-                // `Normal` is the definition's default — only a departure was authored.
-                ['priority', typeof priority === 'string' && priority !== 'Normal' ? tsLiteral(priority) : undefined],
-                ['reference', optStr('reference')],
-                ['deferDate', optStr('deferDate')],
-                ['dueDate', optStr('dueDate')],
-                ['wait', node.type === T.queueCreateAndWait ? 'true' : undefined],
-            ])})`;
-        }
         case T.summarize:
         case T.batchTransform: {
             const attachment = emitVal(inputs.attachment, imp, inputNames);