@uipath/maestro-builder-sdk 6.47.2 → 6.48.0

package/dist/bpmn/serialize.js

@@ -20,6 +20,8 @@ import { createConnectorEvent, createExternalTask, intsvcOutputVar } from './int
 import { createExtensionPayload, createTypedNode, rowDeclaration, typedNodeOutputVar, verbatimOutputRows } from './typed-node.js';
 import { connectorOutputVars, typedNodeDeclaredVars } from './declared-vars.js';
 import { defaultEntryPointId } from './entry-point-id.js';
+import { parseXmlRanges } from './xml-ranges.js';
+import { ownEntry } from '../core/own-entry.js';
 const require = createRequire(import.meta.url);
 const uipathDescriptor = require('./uipath-moddle.v1.json');
 const NS = {
@@ -181,6 +183,22 @@ export async function serialize(built, opts = {}) {
  * of the trade. Revisit if the graders learn to treat absence as interrupting.
  */
 export function finalizeBpmnXml(xml) {
+    return jsonInputBodiesAsCdata(outsideCdata(xml, normalizeMarkup));
+}
+/**
+ * Apply `edit` to the markup only — never inside a CDATA section or a comment.
+ *
+ * The passes below are patterns over the text, and a CDATA payload is author data: a
+ * JSON value holding the literal `&#60;` or `<bpmn:boundaryEvent>` must come out of a
+ * second `finalizeBpmnXml` (or `tidy`) byte for byte, not rewritten as markup.
+ */
+function outsideCdata(xml, edit) {
+    return xml
+        .split(/(<!\[CDATA\[[\s\S]*?\]\]>|<!--[\s\S]*?-->)/)
+        .map((part, i) => (i % 2 === 1 ? part : edit(part)))
+        .join('');
+}
+function normalizeMarkup(xml) {
     return (xml
         .replace(/<bpmn:boundaryEvent\b(?![^>]*\bcancelActivity=)([^>]*?)(\/?)>/g, '<bpmn:boundaryEvent cancelActivity="true"$1$2>')
         // Same reason, other schema default: a PARALLEL multi-instance marker is
@@ -206,6 +224,81 @@ export function finalizeBpmnXml(xml) {
         .replace(/&#(?:34|x22);/g, '&quot;')
         .replace(/&#(?:39|x27);/g, '&apos;'));
 }
+/**
+ * Rewrite every json `uipath:input` text body as CDATA — the one body shape the cloud
+ * engine reads.
+ *
+ * `PO.BpmnEngine`'s `UiPathExtensionsProvider` (`ExtractContextInputs`,
+ * `ExtractActivityInputs`) takes an input's value from an `XCData` child or a `value`
+ * attribute and filters out any row with neither. moddle writes a body as entity-escaped
+ * TEXT, which is neither, so the engine silently dropped every json input the SDK
+ * authored: a script task ran with no `args` (`vars is not defined`), a connector task
+ * sent no body. `check`, `compile` and `uip maestro bpmn validate` all read text and
+ * CDATA alike, so nothing caught it before the run (#1390). Studio Web writes CDATA.
+ *
+ * moddle has no CDATA option for a body property, so this rewrites its output — by
+ * element range (`xml-ranges.ts`), not a pattern over the document. It runs LAST in
+ * `finalizeBpmnXml`, after the markup passes, which skip CDATA (`outsideCdata`), so no
+ * pass reaches into a payload this writes. An input whose content is not plain text (already CDATA,
+ * as `tidy` may hand it, or empty) is left alone, so this is idempotent.
+ */
+function jsonInputBodiesAsCdata(xml) {
+    const bodies = [];
+    const collect = (nodes) => {
+        for (const node of nodes) {
+            if (node.name === 'uipath:input' && node.attributes.type === 'json')
+                bodies.push(node);
+            else
+                collect(node.children);
+        }
+    };
+    collect(parseXmlRanges(xml));
+    let out = xml;
+    // Splice from the end so the earlier offsets stay valid.
+    for (const input of bodies.sort((a, b) => b.innerStart - a.innerStart)) {
+        const text = xml.slice(input.innerStart, input.innerEnd);
+        if (text === '' || text.includes('<'))
+            continue;
+        out = out.slice(0, input.innerStart) + cdata(input.attributes.name ?? '', decodeXmlText(text)) + out.slice(input.innerEnd);
+    }
+    return out;
+}
+const NAMED_ENTITY = { lt: '<', gt: '>', amp: '&', quot: '"', apos: "'" };
+/** Decode XML character data in one pass, so `&amp;lt;` stays the text `&lt;`. */
+function decodeXmlText(text) {
+    return text.replace(/&(?:#(\d+)|#x([0-9a-fA-F]+)|(lt|gt|amp|quot|apos));/g, (_, dec, hex, named) => dec !== undefined
+        ? String.fromCodePoint(Number(dec))
+        : hex !== undefined
+            ? String.fromCodePoint(parseInt(hex, 16))
+            : ownEntry(NAMED_ENTITY, named));
+}
+/**
+ * ONE CDATA section holding `text`'s value.
+ *
+ * A `]]>` cannot sit in a CDATA section, and splitting it across two is no answer: the
+ * engine reads the FIRST `XCData` child only (`OfType<XCData>().FirstOrDefault()`), so it
+ * would get the JSON cut off at the split. In valid JSON a `]]>` can only sit inside a
+ * string (`>` is not JSON outside one), so its `>` is written as the escape `\u003e` —
+ * different bytes, the same value. A body that is not JSON has no such escape and could
+ * only reach the engine truncated, so it is refused.
+ */
+function cdata(name, text) {
+    if (!text.includes(']]>'))
+        return `<![CDATA[${text}]]>`;
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`json input "${name}" contains "]]>" and is not valid JSON, so it cannot be written as the single CDATA section the engine reads.`);
+    }
+    const escaped = text.replaceAll(']]>', ']]\\u003e');
+    // Holds by the argument above; checked because a wrong payload here would be silent.
+    if (JSON.stringify(JSON.parse(escaped)) !== JSON.stringify(value)) {
+        throw new Error(`json input "${name}": escaping "]]>" changed its value.`);
+    }
+    return `<![CDATA[${escaped}]]>`;
+}
 export function processId(id) {
     return /^[A-Za-z_][\w.-]*$/.test(id) ? id : 'Process_1';
 }

package/dist/check.js

@@ -5,11 +5,11 @@
  * duplicate step names, references to undeclared variables/steps, empty branch
  * arms, and missing terminals.
  */
-import { Expr, SCHEDULE_PRESETS, parseIxpProjectType, parallelFork } from './flow-sdk.js';
+import { Expr, SCHEDULE_PRESETS, parallelFork } from './flow-sdk.js';
 import { FlowNode } from './core/node-classes.js';
 import { planContributionBindings } from './core/contribution-bindings.js';
 import { definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
-import { bundledActionNodeType, bundledContainerDefinition, bundledDefinition, perCallDefinition, resolveContributionDefinition } from './serialize.js';
+import { bundledActionNodeType, bundledContainerDefinition, bundledDefinition, resolveContributionDefinition } from './serialize.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';
@@ -528,8 +528,6 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                         outputReaders.set(stepName, (field, rest, at, d) => rule(stepName, field, rest, inputs, at, d));
                     }
                 }
-                if (s.spec.kind === 'ixpExtract')
-                    checkIxpExtract(s.name, s.spec.inputs, diags);
                 if (s.spec.kind === 'waitEvent') {
                     const stepName = s.name;
                     const push = (level) => (code, message, suggestion) => diags.push({
@@ -2194,76 +2192,6 @@ const OUTPUT_READ_RULES = {
             + 'its own false-positive sweep — flow-builder-sdk#855.',
     },
 };
-/**
- * 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
- * mistake" — the current node declares none of them, so each is an input the
- * definition does not have.
- *
- * They are not reachable through `ixpExtract()`'s typed surface, which is the
- * point of having one; this check exists for the JS caller and for a
- * hand-written spec object, where TypeScript is not in the way.
- */
-const IXP_FORBIDDEN_INPUTS = ['digitizationMode', 'documentTaxonomy', 'attachmentId', 'fileName', 'mimeType'];
-/**
- * `ixpExtract(...)`-specific checks.
- *
- * All four identity fields are load-bearing on the tenant and none of them can
- * be derived, so a missing one is an error rather than a warning: the node type
- * is per-project, and the definition's own `inputDefinition` marks `modelName`
- * and `folderKey` required (`minLength: 1`) beside `fileRef` — which is why
- * `flow validate`'s `ixp-node` validator rejects a node with an empty one.
- */
-function checkIxpExtract(step, inputs, diags) {
-    const at = (code, message, suggestion) => {
-        diags.push({ level: 'error', code, message, step, ...(suggestion ? { suggestion } : {}) });
-    };
-    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
-    const project = String(inputs?.project ?? '').trim();
-    if (blank(project)) {
-        at('IXP_NO_PROJECT', `IxP step "${step}" has no \`project\`. That is the extractor's whole node type, and it carries the `
-            + `project version id and folder key the platform resolves the deployment by. Copy it from the registry `
-            + `— never construct it: three different spellings of its tail exist in deployed flows.`, `project: 'uipath.ixp.<slug>.<projectVersionId>-<folderKey>'  // uip maestro flow registry pull --force && uip maestro flow registry search -f "type:startsWith=uipath.ixp"`);
-    }
-    else if (!project.startsWith('uipath.ixp.')) {
-        at('IXP_PROJECT_NOT_NODE_TYPE', `IxP step "${step}"'s \`project\` is ${JSON.stringify(inputs.project)}, which is not a \`uipath.ixp.*\` node `
-            + `type. This field takes the type verbatim from \`registry search\`, not the project's name or id — the `
-            + `name goes in \`name\` and the slug in \`modelName\`.`);
-    }
-    else if (parseIxpProjectType(project) === undefined) {
-        at('IXP_PROJECT_TAIL_UNPARSEABLE', `IxP step "${step}"'s \`project\` ends in ${JSON.stringify(project.slice(project.lastIndexOf('.') + 1))}, which is `
-            + `not the \`<projectVersionId>-<folderKey>\` pair of uuids the current registry serves. Two older spellings `
-            + `exist in the corpus — a sanitized folder path, and the literal string "undefined" — and neither resolves `
-            + `today. Re-read the type from \`registry search\` after \`registry pull --force\`.`);
-    }
-    if (blank(inputs?.modelName)) {
-        at('IXP_NO_MODEL_NAME', `IxP step "${step}" has no \`modelName\`. The definition marks it required (\`minLength: 1\`) and the `
-            + `platform's \`ixp-node\` validator refuses an empty one — it is the project's own name as the tenant `
-            + `spells it, which the node type's slug has lower-cased and de-punctuated beyond recovery.`, `modelName: 'invoiceixp-cef0d447-ixp'  // registry get → inputDefaults.modelName`);
-    }
-    if (blank(inputs?.name)) {
-        at('IXP_NO_NAME', `IxP step "${step}" has no \`name\`. It is the deployment's display name — the \`ixpDeployment\` binding's `
-            + `\`name\`, which is how the deployed flow finds the project.`, `name: 'InvoiceIXP'  // registry get → inputDefaults.model.modelDisplayName`);
-    }
-    if (blank(inputs?.folderName)) {
-        at('IXP_NO_FOLDER', `IxP step "${step}" has no \`folderName\`. IxP deployments are folder-scoped, and this is the binding's `
-            + `\`folderPath\` default — the folder the runtime looks in.`, `folderName: 'Shared'  // registry get → inputDefaults.folderName`);
-    }
-    const fileRef = inputs?.fileRef;
-    if (fileRef === undefined || fileRef === null
-        || (typeof fileRef === 'string' && fileRef.trim() === '')) {
-        at('IXP_NO_FILE', `IxP step "${step}" has no \`fileRef\`. It is the node's only required INPUT (\`inputDefinition.required\`) `
-            + `and it takes a whole Flow Attachment object — normally a \`file\`-typed flow input.`, `fileRef: out('start', 'invoiceFile')   // .input({ invoiceFile: types.file })`);
-    }
-    for (const f of IXP_FORBIDDEN_INPUTS) {
-        if (inputs?.[f] !== undefined) {
-            at('IXP_FORBIDDEN_INPUT', `IxP step "${step}" sets \`${f}\`, which the current node does not declare — it belonged to a prior `
-                + `schema. ${f === 'documentTaxonomy' ? 'The taxonomy travels in the resolved `model` blob.'
-                    : f === 'digitizationMode' ? 'The serializer defaults it to `fileUpload` internally.'
-                        : 'It is derived from `fileRef` upstream.'}`);
-        }
-    }
-}
 /** 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.
@@ -3093,30 +3021,11 @@ placed, carried) {
     const bundledDef = bundledType
         ? bundledDefinition(bundledType, pinned) ?? (pinned !== undefined ? carried?.(bundledType, pinned) : undefined)
         : undefined;
-    // A per-tenant family: ask the definition serialize synthesizes for it (#1040).
-    let perCallDef;
-    if (!bundledType) {
-        try {
-            perCallDef = perCallDefinition(spec);
-        }
-        catch {
-            // The family's own checks report a spec its builder cannot lower.
-            return;
-        }
-    }
-    const def = bundledType ? bundledDef : perCallDef;
-    const noPort = def !== undefined
-        ? !definitionHasErrorPort(def)
+    // Every per-tenant family is registered and answers above (its errorPort, or
+    // a carried definition); what is left is bundled, or has no definition here.
+    const noPort = bundledDef !== undefined
+        ? !definitionHasErrorPort(bundledDef)
         : !bundledType && !NO_DEFINITION_ERROR_PORT_KINDS.has(spec.kind);
-    if (noPort && perCallDef !== undefined) {
-        diags.push({
-            level: 'error',
-            code: 'ONERROR_NO_ERROR_PORT',
-            message: errorPortRefusal(step.name, perCallDef, { bundled: true }),
-            step: step.name,
-        });
-        return;
-    }
     if (noPort) {
         diags.push({
             level: 'error',

package/dist/core/actions.d.ts

@@ -257,98 +257,6 @@ export interface InOutField extends FormFieldSettings {
     required?: boolean;
 }
 export type FormField = ShownField | AskedField | InOutField;
-/**
- * Split an extractor's node type into the two GUIDs its tail packs.
- *
- * `uipath.ixp.<projectSlug>.<projectVersionId>-<folderKey>` — the version id is
- * the `ixpDeployment` binding's `resourceKey` and the node's `model.id`; the
- * folder key is `inputs.folderKey`. Returns `undefined` for a tail that is not
- * exactly two uuids joined by `-`, which is how the two older spellings (a
- * sanitized folder path, and the literal string `undefined`) are refused rather
- * than mis-split.
- *
- * @internal Public for compatibility; not an authoring factory.
- */
-export declare function parseIxpProjectType(nodeType: string): {
-    slug: string;
-    versionId: string;
-    folderKey: string;
-} | undefined;
-export interface IxpExtractInputs {
-    /**
-     * The extractor's node type, verbatim from
-     * `uip maestro flow registry search -f "type:startsWith=uipath.ixp"` — e.g.
-     * `'uipath.ixp.invoiceixp-cef0d447-ixp.ff973488-5d89-8035-86ac-f980b4be6deb-c4359cde-55f0-4f0e-9322-c6cdce74ab4c'`.
-     *
-     * **Run `uip maestro flow registry pull --force` first.** `registry search`
-     * and `registry get` answer from a local cache (`~/.uipath/nodes/`), so
-     * without a pull you are reading whenever you last synced.
-     *
-     * Two GUIDs are packed in that tail — the project **version** id and the
-     * **folder** key — and both are read back out of it here, which is why
-     * nothing else has to be passed twice.
-     */
-    project: string;
-    /**
-     * The project's own name, as the tenant spells it — the slug, e.g.
-     * `'idp-benchmark---invoices-c735405a-ixp'`. It is
-     * `inputDefaults.modelName` in `registry get`, and the node carries it as
-     * both `modelName` and `projectName` (one value, two fields — the designer
-     * shows it in two disabled boxes).
-     *
-     * It cannot be recovered from {@link IxpExtractInputs.project}: the node type's slug is
-     * lower-cased and de-punctuated (`---` collapses to `-`), which does not
-     * invert.
-     */
-    modelName: string;
-    /**
-     * The deployment's display name, e.g. `'InvoiceIXP'` —
-     * `inputDefaults.model.modelDisplayName`. It becomes the node's
-     * `model.modelDisplayName` and the `ixpDeployment` binding's `name`.
-     */
-    name: string;
-    /**
-     * The folder the project is published in, e.g. `'Shared'` or
-     * `'Shared/uipath-maestro-flow/BillingDispute'` —
-     * `inputDefaults.folderName`. It becomes the binding's `folderPath` default
-     * and the definition's own `description`.
-     */
-    folderName: string;
-    /**
-     * The document to extract from — a whole **Flow Attachment** object, the same
-     * shape and the same two ways of referencing it as
-     * {@link SummarizeInputs.attachment}:
-     *
-     * ```ts
-     * flow('InvoiceIntake')
-     *   .input({ invoiceFile: types.file })
-     *   .step('extract', ixpExtract({ …, fileRef: out('start', 'invoiceFile') }))
-     * ```
-     *
-     * It is the node's only authored input, and the definition marks it
-     * `required` (with `modelName` and `folderKey`, which this factory fills in).
-     */
-    fileRef: Expr;
-    /** Pages to process, e.g. `'1-5'`. Empty (the default) means the whole document. */
-    pageRange?: string;
-    /** Pin a published version tag. Empty (the default) means the latest. */
-    versionTag?: string;
-    /**
-     * The folder's key CHAIN, when the project lives in a nested folder —
-     * `inputDefaults.model.folderPath`, a dot-joined path of ancestor folder keys
-     * (`<root>.<parent>.<folder>`). Defaults to the folder key alone, which is
-     * what the platform writes for a project published straight into `Shared`.
-     */
-    folderPath?: string;
-    /**
-     * A free-text note on the node. Off by default, deliberately: the definition
-     * does not declare it (so setting it draws a "sets an input its type does not
-     * declare" warning unless the emitted definition is widened in the same
-     * write, which this does), and it is empty in 114 of the 117 deployed nodes
-     * that carry it at all.
-     */
-    description?: string;
-}
 /**
  * Where a process resource lives: deployed to an Orchestrator folder
  * (`'published'`, the default) or a sibling project of the SAME solution
@@ -914,10 +822,6 @@ export interface ContextIndexRef extends AgentResourcePlacement {
  * whole body rather than an inputs payload.
  */
 export interface FlowActionSpecs {
-    /** The spec {@link ixpExtract} builds. */
-    ixpExtract: {
-        inputs: IxpExtractInputs;
-    };
     /** The spec {@link connector} builds. */
     connector: {
         /** The connector key, e.g. `'uipath-salesforce-slack'`. */
@@ -977,61 +881,6 @@ export declare function builtinActionSpec<S extends object>(spec: S): S;
  * @returns The same spec, as a `FlowTrigger` instance.
  */
 export declare function builtinTriggerSpec<S extends object>(spec: S): S;
-/**
- * Extract fields from a document with a published IxP project — the platform's
- * **Extract** node (`uipath.ixp.*`, service contract `IXP.Extraction`).
- *
- * @remarks
- * **The result's shape is three levels deep and PascalCase.** A field lands at
- * `out('<step>', 'ExtractionResult.ResultsDocument.Fields')` — an array of
- * `{ FieldId, FieldName, FieldType, IsMissing, Values[], Confidence }`, looked
- * up by `FieldName`. `Fields[]` is under `ResultsDocument`, not directly under
- * `ExtractionResult`, and there is no `result` wrapper: the platform's
- * serializer strips it before the value reaches the variable.
- *
- * **A local run cannot extract anything** — extraction needs a real document on
- * the IxP service. An offline run returns the baked
- * fixture shape, and only a platform run reaches the model. So a green local
- * rung proves the wiring and the definition, never that a document was read.
- *
- * **`fileRef` is emitted as a PLAIN `=js:` string, not the expression envelope
- * the rest of the file uses** — the one place this family diverges from the
- * format's general spelling, and the contract this node owes the platform. The
- * product's own `ixp-node` validator tests `typeof fileRef !== 'string'` and
- * refuses the object form (*"inputs.fileRef must be a `=js:$vars.…`
- * expression"*), the node's registry manifest declares
- * `{type:'string', minLength:1}`, and so do all 150 v1-authored instances in the
- * deployed corpus that carry the field — at file versions 1.6, 1.8 and 1.9 alike,
- * with zero envelopes among them. The RUNTIME
- * accepts both, so only `uip maestro flow validate` sees a wrong one; the
- * emitter's exemption lives in `migrate.ts` (`UNWRAPPED_INPUTS`).
- * See the IxP node reference (`website/reference/ixp.md`) §3.
- *
- * @example
- * **Extract an invoice total and read it out of the nested result**
- * ```ts
- * flow('InvoiceIntake')
- *   .input({ invoiceFile: types.file })
- *   .output({ total: types.string })
- *   .step('extract', ixpExtract({
- *     project: 'uipath.ixp.invoiceixp-cef0d447-ixp.ff973488-5d89-8035-86ac-f980b4be6deb-c4359cde-55f0-4f0e-9322-c6cdce74ab4c',
- *     modelName: 'invoiceixp-cef0d447-ixp',
- *     name: 'InvoiceIXP',
- *     folderName: 'Shared',
- *     fileRef: out('start', 'invoiceFile'),
- *   }))
- *   .step('readTotal', script({ code: `
- *     const fields = $vars.extract.output.ExtractionResult.ResultsDocument.Fields || [];
- *     return { total: fields.find(f => f.FieldName === 'invoiceTotal')?.Values?.[0] };
- *   ` }))
- *   .return({ total: out('readTotal', 'total') })
- * ```
- *
- * @param inputs - The published IxP `project` and `modelName`, and the document
- * to read (`fileRef`).
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export declare function ixpExtract(inputs: IxpExtractInputs): 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

@@ -1,44 +1,5 @@
 import { splitConnectorNodeType, isTriggerDescriptor, } from './connectors.js';
 import { FlowAction, FlowTrigger } from './node-classes.js';
-// ─── Document extraction (uipath.ixp.*) ──────────────────────────────────────
-//
-// The platform's *Extract* node (that is its `display.canvasLabel`): it hands a
-// document to a published IxP — Intelligent eXtraction Platform — project and
-// reads the trained model's fields back. Every extractor on a tenant is its own
-// node type, `uipath.ixp.<projectSlug>.<projectVersionId>-<folderKey>`, so the
-// four identity fields below come from the tenant and are named exactly as the
-// node names them.
-//
-// The type is RESOLVED, never constructed: three different spellings of that
-// tail exist in the deployed corpus (the sanitized folder path, the literal
-// string `undefined`, and today's version-id + folder-key pair), so copy the
-// one `registry search` prints.
-/**
- * Split an extractor's node type into the two GUIDs its tail packs.
- *
- * `uipath.ixp.<projectSlug>.<projectVersionId>-<folderKey>` — the version id is
- * the `ixpDeployment` binding's `resourceKey` and the node's `model.id`; the
- * folder key is `inputs.folderKey`. Returns `undefined` for a tail that is not
- * exactly two uuids joined by `-`, which is how the two older spellings (a
- * sanitized folder path, and the literal string `undefined`) are refused rather
- * than mis-split.
- *
- * @internal Public for compatibility; not an authoring factory.
- */
-export function parseIxpProjectType(nodeType) {
-    const rest = nodeType.startsWith('uipath.ixp.') ? nodeType.slice('uipath.ixp.'.length) : undefined;
-    if (!rest)
-        return undefined;
-    const dot = rest.lastIndexOf('.');
-    if (dot <= 0)
-        return undefined;
-    const slug = rest.slice(0, dot);
-    const tail = rest.slice(dot + 1);
-    const m = /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i.exec(tail);
-    if (!m)
-        return undefined;
-    return { slug, versionId: m[1], folderKey: m[2] };
-}
 // ── 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
@@ -88,63 +49,6 @@ export function builtinActionSpec(spec) {
 export function builtinTriggerSpec(spec) {
     return new BuiltinTrigger(spec);
 }
-/**
- * Extract fields from a document with a published IxP project — the platform's
- * **Extract** node (`uipath.ixp.*`, service contract `IXP.Extraction`).
- *
- * @remarks
- * **The result's shape is three levels deep and PascalCase.** A field lands at
- * `out('<step>', 'ExtractionResult.ResultsDocument.Fields')` — an array of
- * `{ FieldId, FieldName, FieldType, IsMissing, Values[], Confidence }`, looked
- * up by `FieldName`. `Fields[]` is under `ResultsDocument`, not directly under
- * `ExtractionResult`, and there is no `result` wrapper: the platform's
- * serializer strips it before the value reaches the variable.
- *
- * **A local run cannot extract anything** — extraction needs a real document on
- * the IxP service. An offline run returns the baked
- * fixture shape, and only a platform run reaches the model. So a green local
- * rung proves the wiring and the definition, never that a document was read.
- *
- * **`fileRef` is emitted as a PLAIN `=js:` string, not the expression envelope
- * the rest of the file uses** — the one place this family diverges from the
- * format's general spelling, and the contract this node owes the platform. The
- * product's own `ixp-node` validator tests `typeof fileRef !== 'string'` and
- * refuses the object form (*"inputs.fileRef must be a `=js:$vars.…`
- * expression"*), the node's registry manifest declares
- * `{type:'string', minLength:1}`, and so do all 150 v1-authored instances in the
- * deployed corpus that carry the field — at file versions 1.6, 1.8 and 1.9 alike,
- * with zero envelopes among them. The RUNTIME
- * accepts both, so only `uip maestro flow validate` sees a wrong one; the
- * emitter's exemption lives in `migrate.ts` (`UNWRAPPED_INPUTS`).
- * See the IxP node reference (`website/reference/ixp.md`) §3.
- *
- * @example
- * **Extract an invoice total and read it out of the nested result**
- * ```ts
- * flow('InvoiceIntake')
- *   .input({ invoiceFile: types.file })
- *   .output({ total: types.string })
- *   .step('extract', ixpExtract({
- *     project: 'uipath.ixp.invoiceixp-cef0d447-ixp.ff973488-5d89-8035-86ac-f980b4be6deb-c4359cde-55f0-4f0e-9322-c6cdce74ab4c',
- *     modelName: 'invoiceixp-cef0d447-ixp',
- *     name: 'InvoiceIXP',
- *     folderName: 'Shared',
- *     fileRef: out('start', 'invoiceFile'),
- *   }))
- *   .step('readTotal', script({ code: `
- *     const fields = $vars.extract.output.ExtractionResult.ResultsDocument.Fields || [];
- *     return { total: fields.find(f => f.FieldName === 'invoiceTotal')?.Values?.[0] };
- *   ` }))
- *   .return({ total: out('readTotal', 'total') })
- * ```
- *
- * @param inputs - The published IxP `project` and `modelName`, and the document
- * to read (`fileRef`).
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function ixpExtract(inputs) {
-    return builtinActionSpec({ kind: 'ixpExtract', inputs });
-}
 export function connector(a, b, c, d) {
     if (typeof a === 'string') {
         const opts = (d ?? {});

package/dist/core/nodes/registry.d.ts

@@ -52,7 +52,8 @@ export declare class NodeTypeRegistry<Ctx extends ArtifactContexts> {
     typesOfKind(kind: string): readonly Registered<Ctx>[];
     /**
      * The node type for a type name in the file — the exact name, else the type
-     * whose `typeNamePrefix` it starts with — or undefined when no type owns it.
+     * whose `typeNamePrefix` it starts with (and whose `typeNameMatches`, if any,
+     * accepts it) — or undefined when no type owns it.
      * The bare prefix counts: it is what an empty `key` builds, and the old lift
      * read it as its factory, so it still does.
      */

package/dist/core/nodes/registry.js

@@ -1,5 +1,9 @@
 import { asVersioned } from './versioned.js';
 import { ownEntry } from '../own-entry.js';
+/** Whether a prefix entry owns `typeName`: under its prefix, and accepted by its narrowing, if it has one. */
+function owns(p, typeName) {
+    return typeName.startsWith(p.prefix) && (p.matches?.(typeName) ?? true);
+}
 export class NodeTypeRegistry {
     artifact;
     families;
@@ -44,15 +48,18 @@ export class NodeTypeRegistry {
                     const overlap = this.#byPrefix.find((p) => p.prefix.startsWith(prefix) || prefix.startsWith(p.prefix));
                     if (overlap)
                         problems.push(`${where}: prefix "${prefix}" overlaps "${overlap.prefix}" (${placeOf(overlap.entry)})`);
-                    const shadowed = [...this.#byTypeName.keys()].find((n) => n.startsWith(prefix));
+                    const shadowed = [...this.#byTypeName.keys()].find((n) => n.startsWith(prefix) && (type.typeNameMatches?.(n) ?? true));
                     if (shadowed)
                         problems.push(`${where}: prefix "${prefix}" would also own the registered type "${shadowed}"`);
                 }
                 else {
-                    const owner = this.#byPrefix.find((p) => type.typeName.startsWith(p.prefix));
+                    const owner = this.#byPrefix.find((p) => owns(p, type.typeName));
                     if (owner)
                         problems.push(`${where}: type name "${type.typeName}" falls under the prefix "${owner.prefix}" (${placeOf(owner.entry)})`);
                 }
+                if (type.typeNameMatches !== undefined && type.typeNamePrefix === undefined) {
+                    problems.push(`${where}: typeNameMatches narrows a typeNamePrefix, and the type declares none`);
+                }
                 const typeOwner = this.#byTypeName.get(type.typeName);
                 if (typeOwner) {
                     problems.push(`type name "${type.typeName}" is registered twice (${placeOf(typeOwner)} and ${where}); one VersionedNodeType owns every version of a type`);
@@ -70,7 +77,7 @@ export class NodeTypeRegistry {
                 this.#byKind.set(type.kind, [...(sharing ?? []), entry]);
                 this.#byTypeName.set(type.typeName, entry);
                 if (type.typeNamePrefix !== undefined) {
-                    this.#byPrefix.push({ prefix: type.typeNamePrefix, entry });
+                    this.#byPrefix.push({ prefix: type.typeNamePrefix, matches: type.typeNameMatches?.bind(type), entry });
                 }
             }
         }
@@ -102,7 +109,8 @@ export class NodeTypeRegistry {
     }
     /**
      * The node type for a type name in the file — the exact name, else the type
-     * whose `typeNamePrefix` it starts with — or undefined when no type owns it.
+     * whose `typeNamePrefix` it starts with (and whose `typeNameMatches`, if any,
+     * accepts it) — or undefined when no type owns it.
      * The bare prefix counts: it is what an empty `key` builds, and the old lift
      * read it as its factory, so it still does.
      */
@@ -110,7 +118,7 @@ export class NodeTypeRegistry {
         const exact = this.#byTypeName.get(typeName);
         if (exact)
             return exact;
-        return this.#byPrefix.find((p) => typeName.startsWith(p.prefix))?.entry;
+        return this.#byPrefix.find((p) => owns(p, typeName))?.entry;
     }
     /** Every registered kind, sorted. */
     kinds() {

package/dist/core/nodes/versioned.d.ts

@@ -25,6 +25,14 @@ Impl extends NodeType<Spec, Serialized, Ctx> = NodeType<Spec, Serialized, Ctx>>
      * per-tenant: no definition could be bundled for a name the SDK cannot know.
      */
     readonly typeNamePrefix?: string;
+    /**
+     * Narrows {@link typeNamePrefix}: the type owns a name under the prefix only
+     * when this accepts it. For a family whose names share a stem with exact names
+     * of other types — an IxP extractor is `uipath.ixp.<slug>.<versionId>-<folderKey>`,
+     * beside `uipath.ixp.extract-document-builder` — the registry then lets an
+     * exact name sit under the prefix as long as this rejects it.
+     */
+    typeNameMatches?(typeName: string): boolean;
     readonly factory: string;
     /** The version used when the author names none. Changing it is a breaking change. */
     readonly defaultVersion: string;

package/dist/decompile.js

@@ -38,7 +38,6 @@ import { commentText } from './core/comment-text.js';
 import { tsKey as key, tsLiteral, tsNumber, tsObject as objLit, tsOptions as opts, tsText } from './core/ts-literal.js';
 import { wireExprBody } from './core/wire-expr.js';
 import { hasExits } from './core/step-ports.js';
-import { parseIxpProjectType } from './core/actions.js';
 import { readFlowGlobals } from './flow-variables.js';
 import { outputBackingGlobal, outputBackingName } from './flow-output-backing.js';
 import { mapJsCode } from './core/js-code-spans.js';
@@ -802,36 +801,6 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
                 if (sub !== undefined)
                     return `${imp.use('waitForEvent')}(${sub})`;
             }
-            // A published IxP extractor: `uipath.ixp.<slug>.<versionId>-<folderKey>`.
-            // The document-processing pair (`uipath.ixp.extract-document-builder`,
-            // `uipath.document.classify`) are their own families, handled above and
-            // excluded here by the parse — their tails are not the GUID pair.
-            if (node.type.startsWith('uipath.ixp.') && parseIxpProjectType(node.type) !== undefined) {
-                const i = (node.inputs ?? {});
-                const plain = (k) => {
-                    const v = unwrapSource(i[k]);
-                    return v === undefined || v === '' ? undefined : v;
-                };
-                const fr = unwrapSource(i.fileRef) ?? '';
-                // The DEPLOYMENT's display name is nested in `inputs.model`, not at the
-                // top of `inputs` — the two are different values (the model block's
-                // `modelDisplayName` is 'InvoiceIXP'; `modelName` is the slug), so
-                // reading the wrong one recovers the slug as the name.
-                const model = (i.model ?? {});
-                const nested = (k) => typeof model[k] === 'string' && model[k] !== '' ? model[k] : undefined;
-                return `${imp.use('ixpExtract')}(${opts([
-                    ['project', tsLiteral(node.type)],
-                    // `modelName`/`projectName` are one value in two fields; either recovers it.
-                    ['modelName', tsLiteral(plain('modelName') ?? plain('projectName') ?? nested('modelName') ?? '')],
-                    ['name', tsLiteral(nested('modelDisplayName') ?? plain('modelName') ?? '')],
-                    ['folderName', tsLiteral(plain('folderName') ?? nested('folderName') ?? '')],
-                    ['fileRef', fr.startsWith('=js:') ? emitBareExpr(fr.slice(4), imp, inputNames) : tsLiteral(fr)],
-                    ['pageRange', plain('pageRange') !== undefined ? tsLiteral(plain('pageRange')) : undefined],
-                    ['versionTag', plain('versionTag') !== undefined ? tsLiteral(plain('versionTag')) : undefined],
-                    ['description', plain('description') ?? nested('description') !== undefined
-                            ? tsLiteral((plain('description') ?? nested('description'))) : undefined],
-                ])})`;
-            }
             // Every family this SDK AUTHORS is recovered above — a guard test asserts
             // it (`flow-decompile-families.test.ts`). Reaching here means a node type
             // the SDK cannot author: a hand-written file, a newer platform family, or