@uipath/maestro-builder-sdk 6.18.10 → 6.20.0

package/dist/core/process-resource-sort-order.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The palette `sortOrder` of a process-resource node (an RPA workflow, API
+ * workflow, function, agent, or agentic process, published or in-solution),
+ * derived the way the platform derives it.
+ *
+ * flow-core's `buildNodeManifest` (`@uipath/flow-core/manifest`) does not keep a
+ * per-family number. It writes `categorySortOrders[baseCategory] +
+ * DYNAMIC_NODE_SORT_OFFSET`, where `baseCategory` is the resource type's category
+ * (`agent`, `flow`, …) before any `published` / `in-solution` listing suffix. So
+ * this module keeps the same two inputs and the same sum, not five literals.
+ *
+ * The base values are flow-core 0.115.4's `baseCategorySortOrders` for these
+ * categories (read 2026-10-08). They match what the platform writes today:
+ * `registry get` on alpha/codereval returns agent 510, flow 600, agentic-process
+ * 610, case-management 620, rpa-workflow 630, api-workflow 640, function 650, and
+ * 54 of 54 v1 in-solution agent `.flow` files (09-01 to 10-08) carry 510.
+ *
+ * flow-core renumbered these once already (agent was 5, api-workflow 10,
+ * rpa-workflow 30). `tests/process-resource-sort-order.test.ts` compares this
+ * table with a local flow-core when one is present, so the next renumber shows
+ * up as a red test rather than as a silent diff.
+ */
+export declare const PROCESS_RESOURCE_CATEGORY_SORT_ORDERS: {
+    readonly agent: 10;
+    readonly flow: 100;
+    readonly 'agentic-process': 110;
+    readonly 'case-management': 120;
+    readonly 'rpa-workflow': 130;
+    readonly 'api-workflow': 140;
+    readonly function: 150;
+};
+/** flow-core's `DYNAMIC_NODE_SORT_OFFSET`: every tenant-built node sorts after every static one. */
+export declare const DYNAMIC_NODE_SORT_OFFSET = 500;
+/** A process-resource node category, e.g. `'agent'` or `'rpa-workflow'`. */
+export type ProcessResourceCategory = keyof typeof PROCESS_RESOURCE_CATEGORY_SORT_ORDERS;
+/**
+ * The `sortOrder` the platform writes for a process-resource node of this
+ * category. For instance `resourceNodeSortOrder('agent')` is 510.
+ */
+export declare function resourceNodeSortOrder(category: ProcessResourceCategory): number;

package/dist/core/process-resource-sort-order.js

@@ -0,0 +1,44 @@
+import { ownEntry } from './own-entry.js';
+/**
+ * The palette `sortOrder` of a process-resource node (an RPA workflow, API
+ * workflow, function, agent, or agentic process, published or in-solution),
+ * derived the way the platform derives it.
+ *
+ * flow-core's `buildNodeManifest` (`@uipath/flow-core/manifest`) does not keep a
+ * per-family number. It writes `categorySortOrders[baseCategory] +
+ * DYNAMIC_NODE_SORT_OFFSET`, where `baseCategory` is the resource type's category
+ * (`agent`, `flow`, …) before any `published` / `in-solution` listing suffix. So
+ * this module keeps the same two inputs and the same sum, not five literals.
+ *
+ * The base values are flow-core 0.115.4's `baseCategorySortOrders` for these
+ * categories (read 2026-10-08). They match what the platform writes today:
+ * `registry get` on alpha/codereval returns agent 510, flow 600, agentic-process
+ * 610, case-management 620, rpa-workflow 630, api-workflow 640, function 650, and
+ * 54 of 54 v1 in-solution agent `.flow` files (09-01 to 10-08) carry 510.
+ *
+ * flow-core renumbered these once already (agent was 5, api-workflow 10,
+ * rpa-workflow 30). `tests/process-resource-sort-order.test.ts` compares this
+ * table with a local flow-core when one is present, so the next renumber shows
+ * up as a red test rather than as a silent diff.
+ */
+export const PROCESS_RESOURCE_CATEGORY_SORT_ORDERS = {
+    agent: 10,
+    flow: 100,
+    'agentic-process': 110,
+    'case-management': 120,
+    'rpa-workflow': 130,
+    'api-workflow': 140,
+    function: 150,
+};
+/** flow-core's `DYNAMIC_NODE_SORT_OFFSET`: every tenant-built node sorts after every static one. */
+export const DYNAMIC_NODE_SORT_OFFSET = 500;
+/**
+ * The `sortOrder` the platform writes for a process-resource node of this
+ * category. For instance `resourceNodeSortOrder('agent')` is 510.
+ */
+export function resourceNodeSortOrder(category) {
+    const base = ownEntry(PROCESS_RESOURCE_CATEGORY_SORT_ORDERS, category);
+    if (base === undefined)
+        throw new Error(`no sortOrder for process-resource category '${category}'`);
+    return base + DYNAMIC_NODE_SORT_OFFSET;
+}

package/dist/core/typed-raw-node.d.ts

@@ -1,19 +1,14 @@
 /**
- * Internal: what `check` and `compile` say about a `rawNode` for a node type
- * the SDK has a typed factory for, and the Data Fabric input keys it may carry.
+ * Internal: what `check` says about a `rawNode` for a node type the SDK has a
+ * typed factory for, for the families not yet on the node-type registry. A
+ * registered type carries its own advice (FlowNodeType.rawNode; raw-node.ts asks
+ * the registry first), so a family's entries leave this table when it is ported.
  * Not re-exported from the package entry point.
  */
-/** The factory to use for one node type, and the versions of it the SDK bundles. */
+/** The factory to use for one node type. */
 export interface TypedFactory {
-    /** The typed spelling, as the refusal names it. */
+    /** The typed spelling, as the warning names it. */
     factory: string;
-    /**
-     * Every `<version>` with a `<nodeType>@<version>` entry in `core-definitions.json`.
-     * Listed here rather than read from the file because this module sits under
-     * `node-classes.ts`, which must not import `node:*`; `raw-node-typed-family.test.ts`
-     * pins the two equal.
-     */
-    bundled: readonly string[];
 }
 /**
  * Every node type the SDK authors as a STEP through a typed factory, with the
@@ -26,33 +21,10 @@ export interface TypedFactory {
  * (`uipath.agent.resource.*`, attached to an agent). `decompile` keeps an
  * orphaned one as a `rawNode`, and a warning on that round trip would be noise.
  *
- * The Data Fabric verbs name their options, because the query and write keys
- * an author reaches for by hand (`_filters`, `_sort`, `fieldValues`, …) each
- * have a typed spelling.
+ * A REGISTERED family's types are not here: they carry the same advice
+ * themselves (the Data Fabric verbs, since Phase 3).
  */
 export declare const TYPED_FACTORIES: Readonly<Record<string, TypedFactory>>;
-/**
- * Every `entityConfig` key the product reads or persists on a Data Fabric node,
- * across the four verbs. flow-workbench develop `eed682f19`:
- *
- * - services `serialization/entity-vdo.ts` `interface EntityConfig` (:229-272):
- *   `entityName`, `resultMode`, `_recordLimit`, `_skip`, `_sort`,
- *   `_selectedFieldNames`, `_filters`, `_entityFields`, `_relatedFields`,
- *   `_folderKey`, `_entityKey`, `_resourceKey`, `_outputSchema`;
- *   `CreateEntityConfig` (:719) adds `fieldValues`; `UpdateEntityConfig` (:744)
- *   adds `recordSource`, `readEntityNodeId`, `recordId`, `fieldUpdates`.
- * - canvas `properties-panel/EntityConfigField.tsx` `EntityConfigInputs`
- *   (:85-110) and `entity/useEntityPanelState.ts` `EntitySelectionPatch`
- *   (:248-270), which the panels persist on an entity pick:
- *   `_entityDisplayName`, `_choiceSets`, `_folderPath`, `_entitySubType`.
- * - Create/Update/DeleteEntityConfigField.tsx declare nothing beyond these.
- *
- * One union rather than one set per verb: a key another verb reads is at worst
- * ignored, and a per-verb split would refuse a canvas-written key on a verb
- * whose panel happens not to declare it. The test pins every key the typed
- * factories write to this set.
- */
-export declare const DATAFABRIC_ENTITY_CONFIG_KEYS: ReadonlySet<string>;
 /**
  * A reminder, as a `warning`, that a `rawNode` stands in for a typed factory,
  * or `undefined` for a type with no factory.
@@ -62,36 +34,15 @@ export declare const DATAFABRIC_ENTITY_CONFIG_KEYS: ReadonlySet<string>;
  * related-path filter needs), and nothing checks factory coverage family by
  * family. So the raw node keeps compiling at every version. The one failure
  * the eval archive measured, an invented key the node never reads, is refused
- * by {@link dataFabricUnknownInputs} instead.
+ * by the node type's own `rawNode.inputProblem` instead (Data Fabric).
  *
  * @param nodeType - The definition's `nodeType`, as passed to `rawNode`.
  * @returns The warning, or `undefined` for a type with no typed factory.
  */
 export declare function typedFamilyRawNodeWarning(nodeType: string): string | undefined;
 /**
- * Why a `core.datafabric.*` node's inputs carry a key the product never reads,
- * or `undefined` when they do not.
- *
- * This is where the eval failure became possible. A raw node renders its inputs
- * verbatim, and `core.datafabric.read@1.4`'s registry definition declares only
- * `entityName` and `resultMode`, so `validate` cannot see any other key. Measured
- * on the eval archive (2026-09-23, skill-flow-datafabric-native-contract-intake-pipeline):
- * the agent wrote `_sortOptions: [{ fieldName, isDescending }]` in place of
- * `_sort`, `check` printed "no issues", `validate` said Valid, and the query
- * would have run unsorted. The allowed set is what the product reads
- * ({@link DATAFABRIC_ENTITY_CONFIG_KEYS}), so `_entityFields` and the other
- * canvas snapshots stay legal.
- *
- * Severity follows the version: at a bundled `<nodeType>@<version>` the key set
- * is known, so the key is refused (`error`); at a version this SDK has not
- * synced, a newer node could read a new key, so it is reported (`warning`).
- *
- * @param nodeType - The node's type.
- * @param version - The version the node is emitted at.
- * @param inputs - The node's inputs, before rendering.
- * @returns The diagnostic, or `undefined` for a clean node or a non-Data-Fabric type.
+ * The RAW_NODE_TYPED_FAMILY sentence for `nodeType`, naming its typed `factory`
+ * and appending a family's `hint`. One spelling for the not-yet-ported table
+ * above and for a registered node type's own advice (raw-node.ts).
  */
-export declare function dataFabricUnknownInputs(nodeType: string, version: string, inputs: unknown): {
-    severity: 'error' | 'warning';
-    message: string;
-} | undefined;
+export declare function typedFactoryWarning(nodeType: string, factory: string, hint?: string): string;

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

@@ -1,6 +1,8 @@
 /**
- * Internal: what `check` and `compile` say about a `rawNode` for a node type
- * the SDK has a typed factory for, and the Data Fabric input keys it may carry.
+ * Internal: what `check` says about a `rawNode` for a node type the SDK has a
+ * typed factory for, for the families not yet on the node-type registry. A
+ * registered type carries its own advice (FlowNodeType.rawNode; raw-node.ts asks
+ * the registry first), so a family's entries leave this table when it is ported.
  * Not re-exported from the package entry point.
  */
 import { ownEntry } from './own-entry.js';
@@ -15,110 +17,41 @@ import { ownEntry } from './own-entry.js';
  * (`uipath.agent.resource.*`, attached to an agent). `decompile` keeps an
  * orphaned one as a `rawNode`, and a warning on that round trip would be noise.
  *
- * The Data Fabric verbs name their options, because the query and write keys
- * an author reaches for by hand (`_filters`, `_sort`, `fieldValues`, …) each
- * have a typed spelling.
+ * A REGISTERED family's types are not here: they carry the same advice
+ * themselves (the Data Fabric verbs, since Phase 3).
  */
 export const TYPED_FACTORIES = {
-    'core.action.http': { factory: 'http({ managed: false })', bundled: ['1.0.0'] },
-    'core.action.http.v2': { factory: 'http({ managed: true })', bundled: ['2.3'] },
-    'core.action.queue.create': { factory: 'queueItem()', bundled: ['1.2'] },
-    'core.action.queue.create-and-wait': { factory: 'queueItem({ wait: true })', bundled: ['1.2'] },
-    'core.action.script': { factory: 'script()', bundled: ['1.0.0', '1.1'] },
-    'core.action.transform': { factory: 'transform()', bundled: ['1.0.0', '1.1'] },
-    'core.action.transform.filter': { factory: "transform({ variant: 'filter' })", bundled: ['1.0.0', '1.1'] },
-    'core.action.transform.group-by': { factory: "transform({ variant: 'group-by' })", bundled: ['1.0.0', '1.1'] },
-    'core.action.transform.map': { factory: "transform({ variant: 'map' })", bundled: ['1.0.0', '1.1'] },
-    'core.control.end': { factory: '.return()', bundled: ['1.0.0', '1.0'] },
-    'core.datafabric.read': {
-        factory: "dataFabricRead({ entity, resultMode: 'single' | 'multiple', filters: [{ field, operator, value, or }], "
-            + 'sort: { field, direction }, limit, skip, fields, folderKey })',
-        bundled: ['1.0', '1.4'],
-    },
-    'core.datafabric.create': {
-        factory: 'dataFabricCreate({ entity, values: { <field>: <value> }, folderKey })',
-        bundled: ['1.3'],
-    },
-    'core.datafabric.update': {
-        factory: 'dataFabricUpdate({ entity, record: { byId } | { fromRead }, set: { <field>: <value> }, folderKey })',
-        bundled: ['1.0', '1.3'],
-    },
-    'core.datafabric.delete': {
-        factory: 'dataFabricDelete({ entity, record: { byId } | { fromRead }, folderKey })',
-        bundled: ['1.3'],
-    },
-    'core.logic.decision': { factory: '.branch()', bundled: ['1.0.0', '1.3'] },
-    'core.logic.delay': { factory: 'delay({ duration })', bundled: ['1.0.0', '1.0'] },
-    'core.logic.dowhile': { factory: '.doWhile(name, condition, body, { limit, breakEnabled })', bundled: ['1.0'] },
-    'core.logic.loop': { factory: '.loop()', bundled: ['1.0.0', '2.4'] },
-    'core.logic.merge': { factory: '.parallel() rejoin', bundled: ['1.0.0', '1.0'] },
-    'core.logic.mock': { factory: 'mock()', bundled: ['1.0.0', '1.0'] },
-    'core.logic.switch': { factory: '.switch()', bundled: ['1.0.0', '1.1'] },
-    'core.logic.terminate': { factory: '.terminate()', bundled: ['1.0.0', '1.0'] },
-    'core.subflow': { factory: 'subflow(child, inputs)', bundled: ['1.0.0', '1.0'] },
-    'uipath.agent.autonomous': { factory: 'inlineAgent()', bundled: ['1.2', '1.3', '1.4'] },
-    'uipath.agent.conversational': { factory: 'conversationalAgent()', bundled: ['1.6', '1.7'] },
-    'uipath.agent.voice': { factory: 'voiceAgent()', bundled: ['1.0', '1.1'] },
-    'uipath.conversational.get-conversation-context': { factory: 'conversationContext()', bundled: ['1.0'] },
-    'uipath.conversational.send-message': { factory: 'sendMessage()', bundled: ['1.0', '1.1'] },
-    'uipath.conversational.voice.create-outgoing-call': { factory: 'createOutgoingCall()', bundled: ['1.0'] },
-    'uipath.conversational.voice.end-call': { factory: 'endCall()', bundled: ['1.0'] },
-    'uipath.conversational.wait-for-message': { factory: 'waitForMessage()', bundled: ['1.0', '1.1'] },
-    'uipath.document.classify': { factory: 'documentClassify()', bundled: ['1.0'] },
-    'uipath.human-in-the-loop': { factory: 'hitl()', bundled: ['1.0', '1.1', '1.2'] },
+    '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 })' },
+    'core.logic.loop': { factory: '.loop()' },
+    'core.logic.merge': { factory: '.parallel() rejoin' },
+    'core.logic.switch': { factory: '.switch()' },
+    'core.logic.terminate': { factory: '.terminate()' },
+    'core.subflow': { factory: 'subflow(child, inputs)' },
+    'uipath.agent.autonomous': { factory: 'inlineAgent()' },
+    'uipath.agent.conversational': { factory: 'conversationalAgent()' },
+    'uipath.agent.voice': { factory: 'voiceAgent()' },
+    'uipath.conversational.get-conversation-context': { factory: 'conversationContext()' },
+    'uipath.conversational.send-message': { factory: 'sendMessage()' },
+    'uipath.conversational.voice.create-outgoing-call': { factory: 'createOutgoingCall()' },
+    'uipath.conversational.voice.end-call': { factory: 'endCall()' },
+    'uipath.conversational.wait-for-message': { factory: 'waitForMessage()' },
+    'uipath.human-in-the-loop': { factory: 'hitl()' },
     'uipath.human-in-the-loop.coded-action-app': {
         factory: "hitl({ variant: 'action-app' })",
-        bundled: ['1.0', '1.1'],
     },
     'uipath.human-in-the-loop.document-validation': {
         factory: "hitl({ variant: 'document-validation' })",
-        bundled: ['1.0'],
     },
-    'uipath.human-in-the-loop.quick-form': { factory: "hitl({ variant: 'quick-form' })", bundled: ['1.0', '1.1'] },
-    'uipath.pattern.batch-transform': { factory: 'batchTransform()', bundled: ['1.0'] },
-    'uipath.pattern.deep-rag': { factory: 'summarize()', bundled: ['1.0'] },
-    'uipath.ixp.extract-document-builder': { factory: 'dynamicExtract()', bundled: ['1.0.0'] },
+    'uipath.human-in-the-loop.quick-form': { factory: "hitl({ variant: 'quick-form' })" },
+    'uipath.pattern.batch-transform': { factory: 'batchTransform()' },
+    'uipath.pattern.deep-rag': { factory: 'summarize()' },
 };
-/**
- * Every `entityConfig` key the product reads or persists on a Data Fabric node,
- * across the four verbs. flow-workbench develop `eed682f19`:
- *
- * - services `serialization/entity-vdo.ts` `interface EntityConfig` (:229-272):
- *   `entityName`, `resultMode`, `_recordLimit`, `_skip`, `_sort`,
- *   `_selectedFieldNames`, `_filters`, `_entityFields`, `_relatedFields`,
- *   `_folderKey`, `_entityKey`, `_resourceKey`, `_outputSchema`;
- *   `CreateEntityConfig` (:719) adds `fieldValues`; `UpdateEntityConfig` (:744)
- *   adds `recordSource`, `readEntityNodeId`, `recordId`, `fieldUpdates`.
- * - canvas `properties-panel/EntityConfigField.tsx` `EntityConfigInputs`
- *   (:85-110) and `entity/useEntityPanelState.ts` `EntitySelectionPatch`
- *   (:248-270), which the panels persist on an entity pick:
- *   `_entityDisplayName`, `_choiceSets`, `_folderPath`, `_entitySubType`.
- * - Create/Update/DeleteEntityConfigField.tsx declare nothing beyond these.
- *
- * One union rather than one set per verb: a key another verb reads is at worst
- * ignored, and a per-verb split would refuse a canvas-written key on a verb
- * whose panel happens not to declare it. The test pins every key the typed
- * factories write to this set.
- */
-export const DATAFABRIC_ENTITY_CONFIG_KEYS = new Set([
-    'entityName', 'resultMode',
-    '_recordLimit', '_skip', '_sort', '_selectedFieldNames', '_filters',
-    '_entityFields', '_relatedFields', '_choiceSets', '_outputSchema',
-    '_folderKey', '_folderPath', '_entityKey', '_resourceKey', '_entityDisplayName', '_entitySubType',
-    'fieldValues', 'fieldUpdates', 'recordSource', 'readEntityNodeId', 'recordId',
-]);
-/**
- * What the Data Fabric factories write, and what they do not, as the typed-family
- * warning states it. The factories do not author the canvas's column snapshots,
- * so a related-path filter (`customer.Name`) still needs a raw node carrying
- * `_entityFields` (core/actions.ts `DataFabricFilter.field`).
- */
-const DATAFABRIC_HINT = ' The factory writes the query and write keys: `filters` becomes `_filters` (flat rows; `or: true` '
-    + 'starts each OR alternative), `sort` is `_sort`, `limit`/`skip`/`fields` are '
-    + '`_recordLimit`/`_skip`/`_selectedFieldNames`, `values`/`set` are `fieldValues`/`fieldUpdates`, '
-    + 'and `record` is `recordSource`. It does not write the column snapshots `_entityFields`, '
-    + '`_relatedFields`, `_choiceSets` or `_outputSchema`; a related-path filter such as '
-    + '`customer.Name` needs `_entityFields`, so for that a raw node is still the way.';
 /**
  * A reminder, as a `warning`, that a `rawNode` stands in for a typed factory,
  * or `undefined` for a type with no factory.
@@ -128,7 +61,7 @@ const DATAFABRIC_HINT = ' The factory writes the query and write keys: `filters`
  * related-path filter needs), and nothing checks factory coverage family by
  * family. So the raw node keeps compiling at every version. The one failure
  * the eval archive measured, an invented key the node never reads, is refused
- * by {@link dataFabricUnknownInputs} instead.
+ * by the node type's own `rawNode.inputProblem` instead (Data Fabric).
  *
  * @param nodeType - The definition's `nodeType`, as passed to `rawNode`.
  * @returns The warning, or `undefined` for a type with no typed factory.
@@ -139,63 +72,16 @@ export function typedFamilyRawNodeWarning(nodeType) {
     const entry = ownEntry(TYPED_FACTORIES, nodeType);
     if (entry === undefined)
         return undefined;
-    const hint = nodeType.startsWith('core.datafabric.') ? DATAFABRIC_HINT : '';
-    return `rawNode("${nodeType}"): this SDK has a typed factory, ${entry.factory}. A raw node keeps its `
-        + `inputs verbatim, and \`validate\` cannot see a key the registry definition does not declare, so a `
-        + `misspelled input compiles and is ignored at run time. Prefer the factory unless you need an input it `
-        + `does not write.${hint}`;
+    return typedFactoryWarning(nodeType, entry.factory);
 }
-const isPlainObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v) && Object.getPrototypeOf(v) === Object.prototype;
 /**
- * Why a `core.datafabric.*` node's inputs carry a key the product never reads,
- * or `undefined` when they do not.
- *
- * This is where the eval failure became possible. A raw node renders its inputs
- * verbatim, and `core.datafabric.read@1.4`'s registry definition declares only
- * `entityName` and `resultMode`, so `validate` cannot see any other key. Measured
- * on the eval archive (2026-09-23, skill-flow-datafabric-native-contract-intake-pipeline):
- * the agent wrote `_sortOptions: [{ fieldName, isDescending }]` in place of
- * `_sort`, `check` printed "no issues", `validate` said Valid, and the query
- * would have run unsorted. The allowed set is what the product reads
- * ({@link DATAFABRIC_ENTITY_CONFIG_KEYS}), so `_entityFields` and the other
- * canvas snapshots stay legal.
- *
- * Severity follows the version: at a bundled `<nodeType>@<version>` the key set
- * is known, so the key is refused (`error`); at a version this SDK has not
- * synced, a newer node could read a new key, so it is reported (`warning`).
- *
- * @param nodeType - The node's type.
- * @param version - The version the node is emitted at.
- * @param inputs - The node's inputs, before rendering.
- * @returns The diagnostic, or `undefined` for a clean node or a non-Data-Fabric type.
+ * The RAW_NODE_TYPED_FAMILY sentence for `nodeType`, naming its typed `factory`
+ * and appending a family's `hint`. One spelling for the not-yet-ported table
+ * above and for a registered node type's own advice (raw-node.ts).
  */
-export function dataFabricUnknownInputs(nodeType, version, inputs) {
-    if (typeof nodeType !== 'string' || !nodeType.startsWith('core.datafabric.'))
-        return undefined;
-    if (!isPlainObject(inputs))
-        return undefined;
-    const unknown = Object.keys(inputs).filter((k) => k !== 'entityConfig');
-    const cfg = inputs.entityConfig;
-    if (isPlainObject(cfg)) {
-        for (const k of Object.keys(cfg))
-            if (!DATAFABRIC_ENTITY_CONFIG_KEYS.has(k))
-                unknown.push(`entityConfig.${k}`);
-    }
-    if (unknown.length === 0)
-        return undefined;
-    const bundled = ownEntry(TYPED_FACTORIES, nodeType)?.bundled.includes(version) ?? false;
-    const named = unknown.map((k) => `\`${k}\``).join(', ');
-    const factory = ownEntry(TYPED_FACTORIES, nodeType)?.factory;
-    const base = `${nodeType}@${version} carries ${named}, which the platform never reads: Data Fabric `
-        + `nodes read only \`inputs.entityConfig\`, with the keys ${[...DATAFABRIC_ENTITY_CONFIG_KEYS].join(', ')} `
-        + `(flow-workbench entity-vdo.ts \`EntityConfig\` and the entity panels). \`validate\` cannot see `
-        + `the key, so it compiles and is ignored at run time; for example a sort is \`_sort: { field, direction }\`, `
-        + `not \`_sortOptions\`.${factory ? ` The typed factory, ${factory}, writes only keys the node reads.` : ''}`;
-    if (bundled)
-        return { severity: 'error', message: base };
-    return {
-        severity: 'warning',
-        message: `${base} This SDK does not bundle ${nodeType}@${version}, so a newer node may read the key; `
-            + 'it compiles as written.',
-    };
+export function typedFactoryWarning(nodeType, factory, hint = '') {
+    return `rawNode("${nodeType}"): this SDK has a typed factory, ${factory}. A raw node keeps its `
+        + `inputs verbatim, and \`validate\` cannot see a key the registry definition does not declare, so a `
+        + `misspelled input compiles and is ignored at run time. Prefer the factory unless you need an input it `
+        + `does not write.${hint}`;
 }

package/dist/core/wire-expr.d.ts

@@ -0,0 +1,27 @@
+/**
+ * core/wire-expr — reading an expression back out of the wire format.
+ *
+ * Shared by decompile and by every node family's deserializer, so the set of
+ * accepted spellings lives in one place.
+ */
+/**
+ * The JS body of a value in an EXPRESSION SLOT: a field that always holds an
+ * expression and never literal text (a branch condition, a loop collection, an
+ * agent input binding, an app input binding, a field binding).
+ *
+ * The wire format has more than one spelling for one expression there, and this
+ * is the one place that knows them all:
+ *
+ *  - `=js:<body>` -- what SDK compile writes.
+ *  - `=<body>` (bare `=`) -- what the product writes for bindings: the CLI's
+ *    agent-input encoder emits `=$vars.<node>.output.<field>` (uipath-cli
+ *    `agent-input-encoding-utils.ts`), and `=$metadata.<key>` the same way.
+ *  - `=vars.<path>` / `=metadata.<path>` -- the PATH form flow-v1 writes for app
+ *    and field bindings. It names the same variable the SDK spells `$vars.<path>`.
+ *  - no prefix -- the slot stores a bare JS body (decision/switch conditions).
+ *
+ * A VALUE slot (an ordinary node input) is different: there only `=js:` marks an
+ * expression and any other string is literal text, as the product reads it
+ * (flow-schema `coerceToExpressionValue`). Do not use this for one.
+ */
+export declare function wireExprBody(raw: string): string;

package/dist/core/wire-expr.js

@@ -0,0 +1,34 @@
+/**
+ * core/wire-expr — reading an expression back out of the wire format.
+ *
+ * Shared by decompile and by every node family's deserializer, so the set of
+ * accepted spellings lives in one place.
+ */
+/**
+ * The JS body of a value in an EXPRESSION SLOT: a field that always holds an
+ * expression and never literal text (a branch condition, a loop collection, an
+ * agent input binding, an app input binding, a field binding).
+ *
+ * The wire format has more than one spelling for one expression there, and this
+ * is the one place that knows them all:
+ *
+ *  - `=js:<body>` -- what SDK compile writes.
+ *  - `=<body>` (bare `=`) -- what the product writes for bindings: the CLI's
+ *    agent-input encoder emits `=$vars.<node>.output.<field>` (uipath-cli
+ *    `agent-input-encoding-utils.ts`), and `=$metadata.<key>` the same way.
+ *  - `=vars.<path>` / `=metadata.<path>` -- the PATH form flow-v1 writes for app
+ *    and field bindings. It names the same variable the SDK spells `$vars.<path>`.
+ *  - no prefix -- the slot stores a bare JS body (decision/switch conditions).
+ *
+ * A VALUE slot (an ordinary node input) is different: there only `=js:` marks an
+ * expression and any other string is literal text, as the product reads it
+ * (flow-schema `coerceToExpressionValue`). Do not use this for one.
+ */
+export function wireExprBody(raw) {
+    if (raw.startsWith('=js:'))
+        return raw.slice(4);
+    if (!raw.startsWith('='))
+        return raw;
+    const body = raw.slice(1);
+    return /^(?:vars|metadata)(?:\.[A-Za-z_$][\w$]*|\[\d+\])*$/.test(body.trim()) ? `$${body.trim()}` : body;
+}

package/dist/decompile-cli.js

@@ -129,7 +129,17 @@ if (!existsSync(BASELINE)) {
   // ask for confirmation before the write. Left as a no-op for now.
   // ---------------------------------------------------------------------------
 
-  const args = [ORIGINAL, EDITED, '-o', MERGED];
+  // \`merge <edited> --original <original>\` is the grammar; the positional
+  // \`merge <original> <edited>\` pair is deprecated. A \`uip\` from before
+  // UiPath/cli#4526 knows only the pair, so ask its \`merge --help\` first.
+  // Key on the door, not the file name: on Windows \`uip\` resolves to node.exe
+  // or a full uip.exe path.
+  const mergeHelp = frontDoor.via === 'uip'
+    ? spawnSync(frontDoor.file, [...frontDoor.prefix, 'merge', '--help'], { encoding: 'utf8' })
+    : undefined;
+  const namedOriginal = mergeHelp === undefined
+    || \`\${mergeHelp.stdout ?? ''}\${mergeHelp.stderr ?? ''}\`.includes('--original');
+  const args = namedOriginal ? [EDITED, '--original', ORIGINAL, '-o', MERGED] : [ORIGINAL, EDITED, '-o', MERGED];
   if (existsSync(BASELINE)) args.push('--baseline', BASELINE);
   run('merge', args);
   console.log('\\n>>> Wrote ' + ${JSON.stringify(base + '.merged.flow')});

package/dist/decompile.d.ts

@@ -128,9 +128,11 @@ export interface DecompileOptions {
     /**
      * Receives each non-fatal finding about the file, one message per finding:
      * a node no trigger reaches (the builder cannot express a detached node, so
-     * the source omits it — strict mode throws instead), and a core
-     * `(type, typeVersion)` pair this SDK does not bundle (the source keeps it;
-     * `compile` will refuse it). The CLI prints these on stderr.
+     * the source omits it — strict mode throws instead), and a
+     * `(type, typeVersion)` pair this SDK cannot resolve for a type it ships at
+     * other versions (the source omits that `{ version }`, so the node compiles at
+     * the SDK's default; `merge` with a baseline keeps the untouched original
+     * node at its version — strict mode throws instead). The CLI prints these on stderr.
      */
     warn?: (message: string) => void;
     /**
@@ -142,6 +144,9 @@ export interface DecompileOptions {
      * (`{{input.start__output__notes}}`), so the recovered source declares its
      * inputs under those names — the same flow, not the same spelling. Without a
      * reader, a shell agent decompiles with empty prompts and a warning.
+     * A context index placed by the canvas or the CLI keeps its real name and
+     * folder only in `<agent source>/resources/<inputs.source>/resource.json`,
+     * which is read the same way.
      */
     readSidecar?: (relativePath: string) => string | undefined;
 }