@uipath/maestro-builder-sdk 6.18.10 → 6.20.0

package/dist/core/actions.js

@@ -1,15 +1,5 @@
 import { splitConnectorNodeType, isTriggerDescriptor, } from './connectors.js';
 import { FlowAction, FlowTrigger } from './node-classes.js';
-/**
- * The operation `type` each variant node must carry — one of, and only.
- *
- * @internal Serializer plumbing; an author states the variant, not the mapping.
- */
-export const VARIANT_OPERATION = {
-    map: 'map',
-    filter: 'filter',
-    'group-by': 'groupBy',
-};
 // ─── Document extraction (uipath.ixp.*) ──────────────────────────────────────
 //
 // The platform's *Extract* node (that is its `display.canvasLabel`): it hands a
@@ -49,18 +39,6 @@ export function parseIxpProjectType(nodeType) {
         return undefined;
     return { slug, versionId: m[1], folderKey: m[2] };
 }
-// ─── Delay (core.logic.delay) ────────────────────────────────────────────────
-/**
- * The twelve durations the designer's dropdown offers. Purely an ENCODING
- * detail: a duration in this list ships as `timerPreset: '<duration>'` and any
- * other ships as `timerPreset: 'custom'` + `timerValue: '<duration>'`. Both
- * deploy and both wait the same length of time — the author never picks.
- * `core-definitions.test.ts` pins this list against the definition's own form.
- */
-export const DELAY_PRESETS = [
-    'PT5S', 'PT15S', 'PT30S', 'PT1M', 'PT5M', 'PT15M', 'PT30M',
-    'PT1H', 'PT6H', 'PT12H', 'P1D', 'P1W',
-];
 // ── Built-in spec adapters ──────────────────────────────────────────────────
 // Every factory result IS a FlowAction/FlowTrigger instance (design §4.4 pass
 // 1), so `instanceof` can tell an SDK-owned construct from a raw literal. The
@@ -125,64 +103,6 @@ export function http(inputs) {
     }
     return builtinActionSpec({ kind: 'http', inputs });
 }
-/**
- * Declare an inline script action.
- *
- * @param inputs - The JavaScript body (`code`, which must `return`) and what it
- * returns (`returns`).
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function script(inputs) {
-    return builtinActionSpec({ kind: 'script', inputs });
-}
-/**
- * Declare a Transform action — a chain of declarative operations over a
- * collection. Read the result downstream with `out('<step>')`.
- *
- * @remarks
- * For a node that does ONE thing, name the variant — the emitted `.flow` then
- * carries `core.action.transform.filter` and reads as `Filter` in the designer
- * instead of a generic `Transform`:
- *
- * ```ts
- * .step('bigOrders', transform({
- *   variant: 'filter',
- *   collection: v('orders'),
- *   operations: [
- *     { type: 'filter', filters: [{ field: 'amount', condition: 'greater_equal', value: 100 }] },
- *   ],
- * }))
- * ```
- *
- * @example
- * **Filter a collection, then reshape what survives**
- * ```ts
- * .var('catalog', types.array, [
- *   { title: 'Deep Learning', author: 'Goodfellow', difficulty: 9, pages: 800 },
- *   { title: 'Information Theory', author: 'MacKay', difficulty: 7, pages: 540 },
- * ])
- * .step('curate', transform({
- *   collection: v('catalog'),
- *   operations: [
- *     { type: 'filter', operation: 'and', filters: [
- *       { field: 'difficulty', condition: 'greater_than', value: 5 },
- *       { field: 'pages', condition: 'less_than', value: 600 },
- *     ] },
- *     { type: 'map', keepOriginalFields: false, mappings: [
- *       { field: 'title', transformation: 'uppercase' },
- *       { field: 'author' },
- *     ] },
- *   ],
- * }))
- * ```
- *
- * @param inputs - The `collection` to transform and the chain of `operations` to
- * run over it.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function transform(inputs) {
-    return builtinActionSpec({ kind: 'transform', inputs });
-}
 /**
  * Declare a human task — a step that pauses for a person to read some values,
  * fill others in, and press one of the outcome buttons.
@@ -374,81 +294,6 @@ export function batchTransform(inputs) {
 export function ixpExtract(inputs) {
     return builtinActionSpec({ kind: 'ixpExtract', inputs });
 }
-/**
- * Declare a delay — a step that pauses the flow for a fixed length of time and
- * then carries on.
- *
- * @remarks
- * A delay produces nothing: there is no `out('settle')` to read. It is a wait,
- * not a value.
- *
- * The node itself splits that one duration across two fields (`timerPreset`
- * holds it directly, or the literal `"custom"` with the real value in
- * `timerValue`); the serializer picks the encoding, so you state the wait once.
- *
- * @example
- * **Wait thirty seconds before carrying on**
- * ```ts
- * .step('settle', delay({ duration: 'PT30S' }))
- * ```
- *
- * @param inputs - How long to wait (`duration`), as an ISO-8601 duration.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function delay(inputs) {
-    // Key presence, not value shape: `{ duration: undefined }` picks the
-    // duration arm and flows to check()'s DELAY_NO_DURATION diagnostic — the
-    // factory only rejects picking BOTH arms or NEITHER.
-    const hasDuration = 'duration' in inputs;
-    const hasUntil = 'until' in inputs;
-    if (hasDuration === hasUntil) {
-        throw new Error("delay() takes exactly ONE of { duration } (an ISO-8601 duration, e.g. 'PT15M') or "
-            + "{ until } (an ISO-8601 date-time, e.g. '2026-09-01T09:00:00Z').");
-    }
-    return builtinActionSpec({ kind: 'delay', inputs });
-}
-/**
- * Declare a PLACEHOLDER step — "a real node goes here later".
- *
- * @remarks
- * A mock takes **no inputs and publishes nothing**. It is a marker on the canvas
- * that keeps the graph wired and the flow deployable while one step is still
- * missing — not a stub that returns test data. `out('extractInvoice')` is
- * refused at compile time (`MOCK_HAS_NO_OUTPUT`) because it would read `null` at
- * run time, always.
- *
- * Say what belongs there in the step's own name and in the label the canvas
- * shows; the corpus's placeholders read like
- * `"Extract Invoice Fields (mock — IxP model not yet published)"`.
- *
- * ### Why there are no arguments (convention #191 — the family contract)
- *
- * The platform's `core.logic.mock@1.0.0` declares **no `inputDefinition`** and one
- * output whose `source` is the literal `"null"`. Measured over the 4,033 distinct
- * archived `.flow` artifacts: **74 mock instances in 62 flows, and 0 carrying a
- * fixture anywhere in the node** — 71 of them with `inputs: {}` or no `inputs`
- * key. The 3 exceptions carry free-text `placeholder` / `_placeholder` keys the
- * definition never declares, invented by agents on runs that scored 0.9 and 0.4.
- *
- * **This is NOT a local runner's `kind: 'mock'` test construct**, which returns a
- * baked fixture. They are different things that share
- * a name, and a `mock({ fixture })` surface would emit a node whose local
- * behaviour and deployed behaviour disagree silently — see
- * [#125](https://github.com/UiPath/flow-builder-sdk/issues/125). Nothing this SDK
- * emits opens that channel: an SDK-authored mock publishes `null` locally,
- * exactly as the platform does.
- *
- * @example
- * **Hold a step's place until the real node exists**
- * ```ts
- * .step('extractInvoice', mock())      // ← swap for the IxP node once the project exists
- * ```
- *
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function mock() {
-    return builtinActionSpec({ kind: 'mock' });
-}
 /**
  * Invoke a deployed RPA (robotic process automation) workflow — a classic
  * UI-automation process, published to Orchestrator, run by a robot.
@@ -764,7 +609,7 @@ export function agenticProcess(inputs) {
  * @remarks
  * **Coded and low-code agents are the same node.** This one factory authors both.
  * `registry get` on a coded agent and on a low-code one returns the same node type,
- * the same service type, the same `sortOrder: 505` and the same bindings shape; the
+ * the same service type, the same `sortOrder` and the same bindings shape; the
  * only difference is the icon, which is what `flavour` sets. Which kind a resource
  * is a property of what somebody published, not of the flow — so if a task asks for
  * "a coded agent", what it is asking you to get right is the RESOURCE you point at.
@@ -866,157 +711,6 @@ export function agent(inputs) {
 export function inlineAgent(inputs) {
     return builtinActionSpec({ kind: 'inlineAgent', inputs });
 }
-/**
- * Classify a document into a document type (`uipath.document.classify`). The
- * result publishes `ClassificationResult` — an array of typed classifications
- * with page ranges and confidences.
- *
- * @param inputs - The file reference and optional page range / split / model settings.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function documentClassify(inputs) {
-    return builtinActionSpec({ kind: 'documentClassify', inputs });
-}
-/**
- * Extract fields from a document with an INLINE schema — Dynamic Extract
- * (`uipath.ixp.extract-document-builder`), the newer of the two extraction
- * shapes. No deployed IXP project is referenced: the extraction schema rides
- * the node. The result publishes `ExtractionResult` (and `Taxonomy`).
- *
- * @param inputs - The file reference, the inline extraction schema, and
- * optional page range / model settings.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function dynamicExtract(inputs) {
-    return builtinActionSpec({ kind: 'dynamicExtract', inputs });
-}
-/**
- * Query entity records from Data Fabric (`core.datafabric.read`). The result
- * publishes to the step's `output`; downstream references re-fetch fresh data
- * at activation time (the engine re-runs the query rather than caching).
- *
- * @remarks
- * This node is **read-one AND query-many**, on its 1.4 definition: `resultMode:
- * 'multiple'` publishes the matching records under `output.results`, and the
- * platform renames the node "Query entity records" to say so. The SDK still
- * pins 1.0 — read-one — as the no-`{ version }` default, so passing
- * `resultMode` is what selects 1.4; see {@link DataFabricReadInputs.resultMode}.
- *
- * The native family covers all four CRUD verbs: this one,
- * {@link dataFabricCreate}, {@link dataFabricUpdate} and
- * {@link dataFabricDelete}. What it does NOT cover is get-by-id, a query row
- * limit, file record fields, and entity events — those are operations on the
- * SAME product reached through its Integration Service connector,
- * `uipath-uipath-dataservice` (the tenant displays it as **UiPath Data
- * Fabric**). So a flow that needs one of those still straddles two surfaces,
- * and the connector remains the one surface that covers everything:
- *
- * ```ts
- * .step('byId', connector('uipath-uipath-dataservice', 'get-entity-record-by-id',
- *   { entityName: 'Contracts', recordId: input('id') }, { connection: 'df' }))
- * ```
- *
- * Get-by-id matters for long text. This node is a query even when it reads one
- * record by an `Id` filter, and a Data Service query returns a PREVIEW of a
- * long-text (`MULTILINE_MAX`) field: the first 10,000 characters plus
- * `...[Truncated]`, with no flag in the output. A 15,551-character value comes
- * back as 10,014 characters. When a field may exceed 10,000 characters, read
- * it with `get-entity-record-by-id`, which returns the whole value
- * (flow-builder-sdk#954).
- *
- * A connector operation's body fields come from the entity, so the library
- * cannot carry them: run `uip maestro registry prepare uipath-uipath-dataservice
- * get-entity-record-by-id -f entityName=<Entity>` first.
- * The routing table is in the `data-fabric.md` reference and the parent-field
- * loop in `connector-params.md` — cited by name rather than linked, because this
- * comment renders both into the flat corpus, where those files sit alongside
- * it, and onto the site, where each symbol is its own page and a relative
- * `./data-fabric` resolves to nothing.
- *
- * @param inputs - The entity, optional filter rows, result mode, and folder scope.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function dataFabricRead(inputs) {
-    return builtinActionSpec({ kind: 'dataFabricRead', inputs });
-}
-/**
- * Create an entity record in Data Fabric (`core.datafabric.create`). The new
- * record publishes to the step's `output`, so a following
- * {@link dataFabricUpdate} or {@link dataFabricDelete} can read its id.
- *
- * @remarks
- * `values` must name at least one column — the node's schema rejects an empty
- * field list rather than inserting a blank row, and `check` says so before the
- * platform does. Field names are the ENTITY's, so copy them from the scenario
- * or the tenant; nothing offline can tell a real column from a typo.
- *
- * The published `output` is the record as a query returns it, so a long-text
- * (`MULTILINE_MAX`) field longer than 10,000 characters comes back cut, with
- * `...[Truncated]` appended, even though the whole value was stored. Use the
- * value you passed in, or re-read the record with the connector's
- * `get-entity-record-by-id`, when the whole text is needed (flow-builder-sdk#954).
- *
- * See {@link dataFabricRead} for what the native family still does not cover
- * and which connector operation covers it.
- *
- * @param inputs - The entity, the columns the record starts with, and folder scope.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function dataFabricCreate(inputs) {
-    return builtinActionSpec({ kind: 'dataFabricCreate', inputs });
-}
-/**
- * Update an entity record in Data Fabric (`core.datafabric.update`). Target the
- * record by id or through an earlier {@link dataFabricRead} step; downstream
- * reads of this step observe the record AFTER the write.
- *
- * @remarks
- * `set` must write at least one column: an empty `set` is a no-op the platform
- * reports as success, so `check` rejects it.
- *
- * See {@link dataFabricRead} for what the native family still does not cover
- * and which connector operation covers it.
- *
- * @param inputs - The entity, the record selector, and the columns to write.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function dataFabricUpdate(inputs) {
-    assertOneRecordRef(inputs.record, 'dataFabricUpdate');
-    return builtinActionSpec({ kind: 'dataFabricUpdate', inputs });
-}
-/**
- * Delete an entity record from Data Fabric (`core.datafabric.delete`). Target
- * the record by id or through an earlier {@link dataFabricRead} step, exactly
- * as {@link dataFabricUpdate} does.
- *
- * @remarks
- * A delete **publishes nothing** — its definition declares no output — so
- * `$vars.<step>.output` is undefined at run time and `check` rejects a read of
- * it. Take what you need off the read step that found the record, before the
- * delete.
- *
- * See {@link dataFabricRead} for what the native family still does not cover
- * and which connector operation covers it.
- *
- * @param inputs - The entity, the record selector, and folder scope.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function dataFabricDelete(inputs) {
-    assertOneRecordRef(inputs.record, 'dataFabricDelete');
-    return builtinActionSpec({ kind: 'dataFabricDelete', inputs });
-}
-/**
- * `record` names exactly ONE of `{ byId }` / `{ fromRead }`. Both forms are
- * optional properties on the same object type, so TypeScript alone cannot
- * refuse `{}` — and an empty selector compiles into a write with no target.
- */
-function assertOneRecordRef(record, factory) {
-    const byId = record?.byId !== undefined;
-    const fromRead = typeof record?.fromRead === 'string';
-    if (byId === fromRead) {
-        throw new Error(`${factory}() targets exactly ONE of record: { byId } or record: { fromRead: '<step>' }.`);
-    }
-}
 /**
  * Declare an Orchestrator QUEUE ITEM step.
  *

package/dist/core/binding-identity.d.ts

@@ -0,0 +1,22 @@
+/**
+ * What a `.flow` binding row binds, as one comparable key.
+ *
+ * The key is `(resource, resourceKey, resourceSubType, propertyAttribute, name)`.
+ * It is NOT the row `id`: nodes never reference a row by id, and the two
+ * producers name rows differently (compile writes `b<Name><Prop>`, the canvas a
+ * random 9-character id), so two rows for the same property never share an id.
+ *
+ * `name` is part of the key. For a connection row it is the definition's own
+ * `<bindings.NAME>` placeholder, and two definitions sharing one connection
+ * spell it differently (`uipath-uipath-http connection`, `uipath-salesforce-slack
+ * connection`); each needs its own row, which is how compile keys them
+ * (`serialize.ts`, flow-builder-sdk#865). Process and queue rows carry
+ * `name === propertyAttribute`, so the extra field does not split them.
+ *
+ * Example: `{ resource: 'process', resourceKey: 'e05d...', resourceSubType: 'Flow',
+ * propertyAttribute: 'name', name: 'name' }` has the same identity whether its
+ * id is `bCalleeName` or `b7CE8ALjn`.
+ */
+export declare function bindingIdentity(b: {
+    readonly [k: string]: unknown;
+}): string;

package/dist/core/binding-identity.js

@@ -0,0 +1,28 @@
+/**
+ * What a `.flow` binding row binds, as one comparable key.
+ *
+ * The key is `(resource, resourceKey, resourceSubType, propertyAttribute, name)`.
+ * It is NOT the row `id`: nodes never reference a row by id, and the two
+ * producers name rows differently (compile writes `b<Name><Prop>`, the canvas a
+ * random 9-character id), so two rows for the same property never share an id.
+ *
+ * `name` is part of the key. For a connection row it is the definition's own
+ * `<bindings.NAME>` placeholder, and two definitions sharing one connection
+ * spell it differently (`uipath-uipath-http connection`, `uipath-salesforce-slack
+ * connection`); each needs its own row, which is how compile keys them
+ * (`serialize.ts`, flow-builder-sdk#865). Process and queue rows carry
+ * `name === propertyAttribute`, so the extra field does not split them.
+ *
+ * Example: `{ resource: 'process', resourceKey: 'e05d...', resourceSubType: 'Flow',
+ * propertyAttribute: 'name', name: 'name' }` has the same identity whether its
+ * id is `bCalleeName` or `b7CE8ALjn`.
+ */
+export function bindingIdentity(b) {
+    return JSON.stringify([
+        b.resource ?? null,
+        b.resourceKey ?? null,
+        b.resourceSubType ?? null,
+        b.propertyAttribute ?? null,
+        b.name ?? null,
+    ]);
+}

package/dist/core/context-index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A context-grounding index's node type, both ways.
+ *
+ * The platform names an index's resource node
+ * `uipath.agent.resource.context.index.<slug>.<uuid>`: the slug is derived from
+ * the index's display name, and the uuid is the index's id. Serialize builds the
+ * type from an author's `{ name, id }`; decompile reads `{ slug, id }` back out
+ * of a file's type. Keeping both directions here is what keeps them inverses.
+ */
+/** The type prefix every context-index resource node shares. */
+export declare const CONTEXT_INDEX_TYPE_PREFIX = "uipath.agent.resource.context.index.";
+/**
+ * The slug for an index name: lower-cased, with every run of non-alphanumerics
+ * collapsed to a single `-`. Measured against the platform's own type for
+ * "Billing Dispute SOP Index" → `billing-dispute-sop-index`, and pinned by a
+ * test, because a derived identifier that disagrees with the registry's is a
+ * node type the tenant has never heard of. A slug never contains a `.`.
+ */
+export declare function contextIndexSlug(name: string): string;
+/** The node type for an index: `…context.index.<slug>.<uuid>`. */
+export declare function contextIndexType(spec: {
+    name: string;
+    id: string;
+}): string;
+/**
+ * The `{ slug, id }` a context-index node type carries, or `undefined` when the
+ * type is not one. The id is everything after the LAST `.`, because a slug has
+ * no dot in it. Either part can be `''` (the SDK once wrote `…<slug>.` for an
+ * index with no id).
+ */
+export declare function parseContextIndexType(type: string): {
+    slug: string;
+    id: string;
+} | undefined;

package/dist/core/context-index.js

@@ -0,0 +1,38 @@
+/**
+ * A context-grounding index's node type, both ways.
+ *
+ * The platform names an index's resource node
+ * `uipath.agent.resource.context.index.<slug>.<uuid>`: the slug is derived from
+ * the index's display name, and the uuid is the index's id. Serialize builds the
+ * type from an author's `{ name, id }`; decompile reads `{ slug, id }` back out
+ * of a file's type. Keeping both directions here is what keeps them inverses.
+ */
+/** The type prefix every context-index resource node shares. */
+export const CONTEXT_INDEX_TYPE_PREFIX = 'uipath.agent.resource.context.index.';
+/**
+ * The slug for an index name: lower-cased, with every run of non-alphanumerics
+ * collapsed to a single `-`. Measured against the platform's own type for
+ * "Billing Dispute SOP Index" → `billing-dispute-sop-index`, and pinned by a
+ * test, because a derived identifier that disagrees with the registry's is a
+ * node type the tenant has never heard of. A slug never contains a `.`.
+ */
+export function contextIndexSlug(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+/** The node type for an index: `…context.index.<slug>.<uuid>`. */
+export function contextIndexType(spec) {
+    return `${CONTEXT_INDEX_TYPE_PREFIX}${contextIndexSlug(spec.name)}.${spec.id}`;
+}
+/**
+ * The `{ slug, id }` a context-index node type carries, or `undefined` when the
+ * type is not one. The id is everything after the LAST `.`, because a slug has
+ * no dot in it. Either part can be `''` (the SDK once wrote `…<slug>.` for an
+ * index with no id).
+ */
+export function parseContextIndexType(type) {
+    if (!type.startsWith(CONTEXT_INDEX_TYPE_PREFIX))
+        return undefined;
+    const tail = type.slice(CONTEXT_INDEX_TYPE_PREFIX.length);
+    const dot = tail.lastIndexOf('.');
+    return dot < 0 ? { slug: tail, id: '' } : { slug: tail.slice(0, dot), id: tail.slice(dot + 1) };
+}

package/dist/core/definitionless-node-types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Node types that never have a `definitions[]` row.
+ *
+ * A `.flow` file pairs every node's `(type, typeVersion)` with a definition —
+ * except these. The platform special-cases them ahead of definition resolution:
+ * a sticky note has no manifest, `flow validate` skips it, BPMN conversion skips
+ * it, and an edge that touches one is dropped. So "this node pins a pair no
+ * definition covers" is a real defect for every other type and the normal state
+ * for these.
+ */
+/** The wire type of a canvas sticky note. */
+export declare const STICKY_NOTE_TYPE = "stickyNote";
+/** The `typeVersion` Studio Web stamps on a sticky note. The type has no manifest to take it from. */
+export declare const STICKY_NOTE_TYPE_VERSION = "1.0.0";
+/** Node types that carry no definition by design. */
+export declare const DEFINITIONLESS_NODE_TYPES: ReadonlySet<string>;

package/dist/core/definitionless-node-types.js

@@ -0,0 +1,16 @@
+/**
+ * Node types that never have a `definitions[]` row.
+ *
+ * A `.flow` file pairs every node's `(type, typeVersion)` with a definition —
+ * except these. The platform special-cases them ahead of definition resolution:
+ * a sticky note has no manifest, `flow validate` skips it, BPMN conversion skips
+ * it, and an edge that touches one is dropped. So "this node pins a pair no
+ * definition covers" is a real defect for every other type and the normal state
+ * for these.
+ */
+/** The wire type of a canvas sticky note. */
+export const STICKY_NOTE_TYPE = 'stickyNote';
+/** The `typeVersion` Studio Web stamps on a sticky note. The type has no manifest to take it from. */
+export const STICKY_NOTE_TYPE_VERSION = '1.0.0';
+/** Node types that carry no definition by design. */
+export const DEFINITIONLESS_NODE_TYPES = new Set([STICKY_NOTE_TYPE]);

package/dist/core/error-port.d.ts

@@ -25,3 +25,9 @@ export declare function definitionHasErrorPort(def: any): boolean;
 export declare function errorPortRefusal(stepName: string, def: any, o?: {
     bundled?: boolean;
 }): string;
+/**
+ * The ONERROR_NO_ERROR_PORT sentence for a registered node type whose definition is
+ * built per tenant and which declares no error port (`errorPort: false`), so there
+ * is no definition to name. Shared with serialize, which throws it for the same node.
+ */
+export declare function declaredErrorPortRefusal(stepName: string, typeName: string, version: string): string;

package/dist/core/error-port.js

@@ -34,3 +34,12 @@ export function errorPortRefusal(stepName, def, o = {}) {
         + `handle the node does not have. Handle the failure downstream instead`
         + (o.bundled ? '.' : `, or pass the definition exactly as \`uip maestro flow registry get\` returns it.`);
 }
+/**
+ * The ONERROR_NO_ERROR_PORT sentence for a registered node type whose definition is
+ * built per tenant and which declares no error port (`errorPort: false`), so there
+ * is no definition to name. Shared with serialize, which throws it for the same node.
+ */
+export function declaredErrorPortRefusal(stepName, typeName, version) {
+    return `Step "${stepName}" is a ${typeName}@${version} node, which has no error port, so the edge would leave a `
+        + 'handle the node does not have. Handle the failure downstream instead.';
+}

package/dist/core/form-field-type.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The product's spellings of the form-field types the SDK models.
+ *
+ * A quick form's field `type` is read by the product through
+ * `@uipath/hitl-schema-types` `normalizeFieldType`. Its canonical stored values
+ * are `string`, `number`, `boolean`, `datetime`, … and it accepts aliases for
+ * each: `text` is an alias of `string`, `date-time` of `datetime`, and .NET
+ * names such as `System.String` resolve too. The designer saves the canonical
+ * value, so a canvas-built form says `"string"`; the SDK (like flow-v1's
+ * serializer and `uip maestro flow hitl add`) writes `text`.
+ *
+ * So `"string"` and `"text"` are the same field on the wire. This table maps
+ * each product spelling of the four types {@link FormFieldType} models to the
+ * SDK's spelling, so decompile hands the author source `check` accepts.
+ * A type the SDK does not model (`integer`, `date`,
+ * `file`, …) has no entry: it stays as written, and `check` reports it.
+ *
+ * Mirrors `resolveFieldType` in `@uipath/hitl-schema-types` 1.1.6, restricted
+ * to the groups that resolve to `string`, `number`, `boolean` and `datetime`
+ * (minus `singleSelect` / `enum` / `union` / …, which resolve to `string` but
+ * are not a plain text box).
+ */
+import type { FormFieldType } from './actions.js';
+/**
+ * The SDK's spelling of a wire form-field type, or `undefined` when the SDK
+ * does not model that type.
+ *
+ * @example
+ * sdkFormFieldType('string')   // 'text'
+ * sdkFormFieldType('datetime') // 'date-time'
+ * sdkFormFieldType('integer')  // undefined
+ */
+export declare function sdkFormFieldType(wire: unknown): FormFieldType | undefined;

package/dist/core/form-field-type.js

@@ -0,0 +1,30 @@
+const PRODUCT_SPELLINGS = {
+    text: 'text',
+    string: 'text',
+    String: 'text',
+    'System.String': 'text',
+    'System.Char': 'text',
+    Char: 'text',
+    number: 'number',
+    Number: 'number',
+    boolean: 'boolean',
+    Boolean: 'boolean',
+    'System.Boolean': 'boolean',
+    'date-time': 'date-time',
+    datetime: 'date-time',
+    dateTime: 'date-time',
+    DateTime: 'date-time',
+    'System.DateTime': 'date-time',
+};
+/**
+ * The SDK's spelling of a wire form-field type, or `undefined` when the SDK
+ * does not model that type.
+ *
+ * @example
+ * sdkFormFieldType('string')   // 'text'
+ * sdkFormFieldType('datetime') // 'date-time'
+ * sdkFormFieldType('integer')  // undefined
+ */
+export function sdkFormFieldType(wire) {
+    return typeof wire === 'string' && Object.hasOwn(PRODUCT_SPELLINGS, wire) ? PRODUCT_SPELLINGS[wire] : undefined;
+}

package/dist/core/hitl-routing.d.ts

@@ -79,6 +79,14 @@ import type { HitlInputs } from './actions.js';
  * nothing else recognises.
  */
 export declare function outcomeSlug(name: unknown, index: number): string;
+/**
+ * The id an outcome is emitted with: the author's `id` when the object form
+ * carries one (a decompiled flow keeps the canvas's ids, for example
+ * `outcome-1778015958049`), else {@link outcomeSlug} of its name. Every reader
+ * of outcome ids goes through this, so the `outcome-<id>` port an edge leaves
+ * from and the id `schema.outcomes[]` declares cannot disagree (#1130).
+ */
+export declare function outcomeIdOf(outcome: unknown, index: number): string;
 /** One outcome's exit. */
 export interface HitlOutcomeExit {
     /** The outcome NAME — what `.stepSwitch` arms and `out('<step>', 'Action')` compare against. */

package/dist/core/hitl-routing.js

@@ -14,6 +14,22 @@ export function outcomeSlug(name, index) {
         .replace(/^-+|-+$/g, '');
     return slug || `outcome-${index + 1}`;
 }
+/**
+ * The id an outcome is emitted with: the author's `id` when the object form
+ * carries one (a decompiled flow keeps the canvas's ids, for example
+ * `outcome-1778015958049`), else {@link outcomeSlug} of its name. Every reader
+ * of outcome ids goes through this, so the `outcome-<id>` port an edge leaves
+ * from and the id `schema.outcomes[]` declares cannot disagree (#1130).
+ */
+export function outcomeIdOf(outcome, index) {
+    if (outcome !== null && typeof outcome === 'object') {
+        const { id, name } = outcome;
+        if (typeof id === 'string' && id !== '')
+            return id;
+        return outcomeSlug(name, index);
+    }
+    return outcomeSlug(outcome, index);
+}
 /**
  * The two human-task node types whose exits the product derives from
  * `inputs.schema.outcomes`. Keyed on TYPE, never on whether `schema.outcomes` is
@@ -33,7 +49,7 @@ export function hitlExitModel(inputs, pinnedVersion) {
         const name = typeof o === 'string' ? o : o?.name;
         return {
             value: String(name ?? ''),
-            port: `outcome-${outcomeSlug(name, i)}`,
+            port: `outcome-${outcomeIdOf(o, i)}`,
             endsProcess: typeof o !== 'string' && o?.action === 'End',
         };
     });