@uipath/maestro-builder-sdk 6.47.3 → 6.49.0

package/dist/bpmn/bpmn-sdk.d.ts

@@ -17,7 +17,7 @@
  *
  * Diagram interchange (`bpmndi`) is intentionally **not** emitted here: BPMN
  * validation is layout-independent, so the SDK emits semantic-only XML and a
- * separate "tidy" step lays it out. See serialize.ts.
+ * `uip maestro bpmn format` lays it out. See serialize.ts.
  */
 import type { TypeDesc } from '../core/expr.js';
 import { type ConnectorOpts, type EventFilter } from '../core/actions.js';

package/dist/bpmn/compile-cli.js

@@ -13,7 +13,7 @@
  *
  * Runs the fast static check first; if it passes, serializes to Maestro `.bpmn`
  * XML (semantic-only — no diagram). The authoritative deploy gate is
- * `uip maestro bpmn validate`; a separate "tidy" step lays the diagram out.
+ * `uip maestro bpmn validate`; `uip maestro bpmn format` lays the diagram out.
  */
 import { reportDiagnostics, reportResult, thrownDiagnostic } from '../cli-result.js';
 import { writeFileSync } from 'node:fs';

package/dist/bpmn/decompile-cli.js

@@ -22,8 +22,8 @@
  * repo-relative for in-tree callers, mirroring the Flow and Case arms.
  *
  * Diagram layout is not read or emitted — the SDK emits semantic-only XML and
- * `tidy` regenerates `bpmndi`. Run `tidy` on the recompiled artifact when a canvas
- * needs one.
+ * `uip maestro bpmn format` regenerates `bpmndi`. Run it on the recompiled artifact
+ * when a canvas needs one.
  *
  * `--style nested` lifts the regions the builder's nesting constructs lower to —
  * see `BpmnDecompileOptions.style`. It is written only after both sources have been

package/dist/bpmn/decompile.js

@@ -16,9 +16,9 @@
  *
  * What does NOT survive, and why:
  *
- * - **`bpmndi` diagram layout.** The SDK emits none and `tidy` regenerates it, so
- *   there is nothing to preserve. A decompiled file recompiles to semantic-only
- *   XML; re-run `tidy` for a canvas.
+ * - **`bpmndi` diagram layout.** The SDK emits none and `uip maestro bpmn format`
+ *   regenerates it, so there is nothing to preserve. A decompiled file recompiles
+ *   to semantic-only XML; re-run `format` for a canvas.
  * - **Comments, method order, and formatting.** Regenerated, not preserved.
  *
  * Everything else round-trips: events and their definitions, all four gateways,

package/dist/bpmn/merge.js

@@ -274,7 +274,7 @@ export function mergeBpmn(originalXml, editedXml, options = {}) {
         originalXml.slice(originalProcess.innerEnd);
     // The diagram: the original's layout survives, which is strictly better than the
     // re-layout a bare recompile forces. Shapes and edges for deleted elements go with
-    // them; anything newly added has no DI yet, which is what `format`/`tidy` is for.
+    // them; anything newly added has no DI yet, which is what `format` is for.
     if (removed.length > 0) {
         const plane = findByLocal(parseXmlRanges(merged), 'BPMNPlane');
         if (plane) {

package/dist/bpmn/serialize.d.ts

@@ -12,8 +12,7 @@ export declare function serialize(built: BuiltBpmn, opts?: BpmnSerializeOpts): P
  * an attribute whose value equals the BPMN default, but Studio Web (and the
  * canvas graders) expect an interrupting boundary event to carry an explicit
  * `cancelActivity="true"`. Add it wherever a boundary event lacks the attribute
- * (its absence already means interrupting). Idempotent; also used by `tidy`,
- * which re-serializes through moddle and drops the attribute again.
+ * (its absence already means interrupting). Idempotent.
  *
  * **This one is a KNOWN divergence from what the product writes, kept on purpose.**
  * None of the 71 boundary events across the five real Studio Web exports in

package/dist/bpmn/serialize.js

@@ -10,8 +10,8 @@
  * descriptor.
  *
  * **Semantic-only, no diagram.** BPMN validation is layout-independent, so no
- * `bpmndi:BPMNDiagram` is emitted here; a separate "tidy" step (auto-layout)
- * adds geometry when a visual diagram is needed.
+ * `bpmndi:BPMNDiagram` is emitted here; `uip maestro bpmn format` adds geometry
+ * when a visual diagram is needed.
  */
 import BpmnModdle from 'bpmn-moddle';
 import { createRequire } from 'node:module';
@@ -170,8 +170,7 @@ export async function serialize(built, opts = {}) {
  * an attribute whose value equals the BPMN default, but Studio Web (and the
  * canvas graders) expect an interrupting boundary event to carry an explicit
  * `cancelActivity="true"`. Add it wherever a boundary event lacks the attribute
- * (its absence already means interrupting). Idempotent; also used by `tidy`,
- * which re-serializes through moddle and drops the attribute again.
+ * (its absence already means interrupting). Idempotent.
  *
  * **This one is a KNOWN divergence from what the product writes, kept on purpose.**
  * None of the 71 boundary events across the five real Studio Web exports in

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/cli/commands/bpmn.js

@@ -53,15 +53,6 @@ export function registerBpmnCommands(program) {
         addValue(argv, '--bindings', options.bindings);
         await invoke('bpmn check', () => import('../../bpmn/check-cli.js'), argv);
     });
-    family.command('tidy')
-        .description('Add diagram layout to a compiled .bpmn artifact.')
-        .argument('<input>', 'input .bpmn path')
-        .option('-o, --output <file>', 'output .bpmn path')
-        .action(async (input, options) => {
-        const argv = [input];
-        addValue(argv, '-o', options.output);
-        await invoke('bpmn tidy', () => import('../../bpmn/tidy-cli.js'), argv);
-    });
     family
         .command('decompile')
         .description('Convert a .bpmn artifact to authored TypeScript.')

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;