@uipath/maestro-builder-sdk 6.18.9 → 6.19.0

package/dist/nodes/delay/flow/factories.js

@@ -0,0 +1,38 @@
+/**
+ * The Delay factory, `delay()`. Moved from core/actions.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; the package entry re-exports it.
+ */
+import { builtinActionSpec } from '../../../core/actions.js';
+/**
+ * Declare a delay — a step that pauses the flow for a fixed length of time and
+ * then carries on.
+ *
+ * @remarks
+ * A delay produces nothing: there is no `out('settle')` to read. It is a wait,
+ * not a value.
+ *
+ * The node itself splits that one duration across two fields (`timerPreset`
+ * holds it directly, or the literal `"custom"` with the real value in
+ * `timerValue`); the serializer picks the encoding, so you state the wait once.
+ *
+ * @example
+ * **Wait thirty seconds before carrying on**
+ * ```ts
+ * .step('settle', delay({ duration: 'PT30S' }))
+ * ```
+ *
+ * @param inputs - How long to wait (`duration`), as an ISO-8601 duration.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export function delay(inputs) {
+    // Key presence, not value shape: `{ duration: undefined }` picks the
+    // duration arm and flows to check()'s DELAY_NO_DURATION diagnostic — the
+    // factory only rejects picking BOTH arms or NEITHER.
+    const hasDuration = 'duration' in inputs;
+    const hasUntil = 'until' in inputs;
+    if (hasDuration === hasUntil) {
+        throw new Error("delay() takes exactly ONE of { duration } (an ISO-8601 duration, e.g. 'PT15M') or "
+            + "{ until } (an ISO-8601 date-time, e.g. '2026-09-01T09:00:00Z').");
+    }
+    return builtinActionSpec({ kind: 'delay', inputs });
+}

package/dist/nodes/delay/flow/family.d.ts

@@ -0,0 +1,3 @@
+/** The Delay node family, as flow-node-registry.ts lists it: `core.logic.delay`. */
+import type { FlowNodeFamily } from '../../../flow-node-type.js';
+export declare const delayFlowFamily: FlowNodeFamily;

package/dist/nodes/delay/flow/family.js

@@ -0,0 +1,8 @@
+import { DELAY_DIAGNOSTICS } from './check.js';
+import { delayNodeType } from './node-type.js';
+export const delayFlowFamily = {
+    id: 'delay',
+    title: 'Delay',
+    types: [delayNodeType],
+    diagnostics: DELAY_DIAGNOSTICS,
+};

package/dist/nodes/delay/flow/index.d.ts

@@ -0,0 +1,3 @@
+/** The Delay family's public surface, which the package entry re-exports. */
+export * from './spec.js';
+export * from './factories.js';

package/dist/nodes/delay/flow/index.js

@@ -0,0 +1,3 @@
+/** The Delay family's public surface, which the package entry re-exports. */
+export * from './spec.js';
+export * from './factories.js';

package/dist/nodes/delay/flow/node-type.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The Delay node type, `core.logic.delay` (bundled 1.0.0 and 1.0). Moved from
+ * serialize.ts / check.ts / decompile.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; serialized output, codes and messages
+ * unchanged.
+ */
+import type { FlowVersionedNodeType } from '../../../flow-node-type.js';
+import { type DelayInputs } from './spec.js';
+export type DelaySpec = {
+    kind: 'delay';
+    inputs: DelayInputs;
+};
+export declare const delayNodeType: FlowVersionedNodeType<DelaySpec>;

package/dist/nodes/delay/flow/node-type.js

@@ -0,0 +1,71 @@
+import { DELAY_PRESETS } from './spec.js';
+import { checkDelay } from './check.js';
+/**
+ * Encode a delay's single `duration` into the two inputs the platform's node
+ * carries — the SAME split as the scheduled trigger above, on the same field
+ * names, because it is the same designer control: `timerPreset` holds the
+ * duration when it is one of the dropdown's twelve, and otherwise holds the
+ * literal `"custom"` with the real duration in `timerValue`. flow-v1's timer
+ * serializer collapses them straight back (`event-definition.ts:31`), so the
+ * two encodings are the same wait.
+ *
+ * Both are shapes the platform actually deploys — 26 of 26 archived
+ * `skill-flow-delay` flows carry the preset form, 35 of 38 archived
+ * `skill-flow-terminate` flows the custom form — so this is a choice of
+ * encoding, not of correctness. Emitting the preset when one fits keeps the
+ * node's Duration dropdown showing a value instead of "Custom".
+ *
+ * `timerType` is `timeDuration` for a `duration` and `timeDate` for `until`,
+ * because the platform's timer serializer resolves a body as
+ * "preset, else timerValue" for EVERY kind and so never reads `timerDate` while
+ * a duration is present (flow-builder-sdk#70).
+ */
+function delayInputs(inputs) {
+    // An absolute-date wait (`until`) is the definition's timeDate arm: it
+    // requires timerDate, while the top-level required timerPreset is satisfied
+    // with the literal 'custom' (the timeDuration-only allOf never fires).
+    const until = String(inputs?.until ?? '').trim();
+    if (until) {
+        return { timerType: 'timeDate', timerPreset: 'custom', timerDate: until };
+    }
+    const duration = String(inputs?.duration ?? '').trim();
+    const isPreset = DELAY_PRESETS.includes(duration);
+    return {
+        timerType: 'timeDuration',
+        timerPreset: isPreset ? duration : 'custom',
+        ...(isPreset ? {} : { timerValue: duration }),
+    };
+}
+function delayAt(version) {
+    return {
+        kind: 'delay', typeName: 'core.logic.delay', version, factory: 'delay', definition: 'bundled',
+        rawNode: { factory: 'delay({ duration })' },
+        serialize: ({ inputs }) => ({ inputs: delayInputs(inputs) }),
+        // The three spellings delayInputs writes — `{ timerType, timerPreset,
+        // timerValue? }` for a duration and `{ timerType: 'timeDate', timerDate }`
+        // for an absolute wait — back to the factory's one.
+        deserialize: (node) => {
+            const inputs = node.inputs ?? {};
+            if (inputs.timerType === 'timeDate') {
+                return { kind: 'delay', inputs: { until: typeof inputs.timerDate === 'string' ? inputs.timerDate : '' } };
+            }
+            const duration = inputs.timerPreset === 'custom'
+                ? (typeof inputs.timerValue === 'string' ? inputs.timerValue : '')
+                : (typeof inputs.timerPreset === 'string' ? inputs.timerPreset : '');
+            return { kind: 'delay', inputs: { duration } };
+        },
+        check: ({ inputs }, ctx) => checkDelay(inputs, ctx),
+        // check collected no expressions for a delay before the port; unchanged by it.
+        expressions: () => [],
+        output: () => ({
+            kind: 'none',
+            code: 'DELAY_HAS_NO_OUTPUT',
+            message: ({ node, ref, reader }) => `Delay "${node}" produces no output, but "${ref}" reads one in "${reader}". `
+                + 'A delay only waits — read the step that computed the value instead.',
+        }),
+    };
+}
+export const delayNodeType = {
+    kind: 'delay', typeName: 'core.logic.delay', factory: 'delay', defaultVersion: '1.0.0',
+    versions: { '1.0.0': delayAt('1.0.0'), '1.0': delayAt('1.0') },
+};

package/dist/nodes/delay/flow/spec.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The Delay family's authoring types (`core.logic.delay`), and its kind's entry in
+ * `FlowActionSpecs`. Moved from core/actions.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md.
+ */
+/**
+ * The twelve durations the designer's dropdown offers. Purely an ENCODING
+ * detail: a duration in this list ships as `timerPreset: '<duration>'` and any
+ * other ships as `timerPreset: 'custom'` + `timerValue: '<duration>'`. Both
+ * deploy and both wait the same length of time — the author never picks.
+ * `core-definitions.test.ts` pins this list against the definition's own form.
+ */
+export declare const DELAY_PRESETS: readonly ["PT5S", "PT15S", "PT30S", "PT1M", "PT5M", "PT15M", "PT30M", "PT1H", "PT6H", "PT12H", "P1D", "P1W"];
+export type DelayInputs = {
+    /**
+     * How long to wait, as an ISO-8601 duration: `PT30S`, `PT15M`, `PT2H`,
+     * `P1D`, `P1W`. `PT` separates the time part, so `P1M` is a MONTH and
+     * `PT1M` is a minute.
+     * ISO-8601 duration format documentation is here:
+     * {@link https://docs.digi.com/resources/documentation/digidocs/90001488-13/reference/r_iso_8601_duration_format.htm}
+     */
+    duration: string;
+    /** Impossible together with `duration` — a delay waits one way or the other. */
+    until?: never;
+} | {
+    /**
+     * Wait until an ABSOLUTE date-time, ISO-8601: `2026-09-01T09:00:00Z` or
+     * `2026-09-01T09:00:00+02:00`. The platform's timeDate timer: the run
+     * parks until the wall clock reaches this moment (already-past dates
+     * fire immediately).
+     */
+    until: string;
+    /** Impossible together with `until` — a delay waits one way or the other. */
+    duration?: never;
+};
+declare module '../../../core/actions.js' {
+    interface FlowActionSpecs {
+        /** The spec {@link delay} builds. */
+        delay: {
+            inputs: DelayInputs;
+        };
+    }
+}

package/dist/nodes/delay/flow/spec.js

@@ -0,0 +1,16 @@
+/**
+ * The Delay family's authoring types (`core.logic.delay`), and its kind's entry in
+ * `FlowActionSpecs`. Moved from core/actions.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md.
+ */
+/**
+ * The twelve durations the designer's dropdown offers. Purely an ENCODING
+ * detail: a duration in this list ships as `timerPreset: '<duration>'` and any
+ * other ships as `timerPreset: 'custom'` + `timerValue: '<duration>'`. Both
+ * deploy and both wait the same length of time — the author never picks.
+ * `core-definitions.test.ts` pins this list against the definition's own form.
+ */
+export const DELAY_PRESETS = [
+    'PT5S', 'PT15S', 'PT30S', 'PT1M', 'PT5M', 'PT15M', 'PT30M',
+    'PT1H', 'PT6H', 'PT12H', 'P1D', 'P1W',
+];

package/dist/nodes/document/flow/factories.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The document factories, `documentClassify()` and `dynamicExtract()`. Moved
+ * from core/actions.ts in Phase 4 of docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; the
+ * package entry re-exports them.
+ */
+import { type ActionSpec } from '../../../core/actions.js';
+import type { DocumentClassifyInputs, DynamicExtractInputs } from './spec.js';
+/**
+ * Classify a document into a document type (`uipath.document.classify`). The
+ * result publishes `ClassificationResult` — an array of typed classifications
+ * with page ranges and confidences.
+ *
+ * @param inputs - The file reference and optional page range / split / model settings.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export declare function documentClassify(inputs: DocumentClassifyInputs): ActionSpec;
+/**
+ * Extract fields from a document with an INLINE schema — Dynamic Extract
+ * (`uipath.ixp.extract-document-builder`), the newer of the two extraction
+ * shapes. No deployed IXP project is referenced: the extraction schema rides
+ * the node. The result publishes `ExtractionResult` (and `Taxonomy`).
+ *
+ * @param inputs - The file reference, the inline extraction schema, and
+ * optional page range / model settings.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export declare function dynamicExtract(inputs: DynamicExtractInputs): ActionSpec;

package/dist/nodes/document/flow/factories.js

@@ -0,0 +1,30 @@
+/**
+ * The document factories, `documentClassify()` and `dynamicExtract()`. Moved
+ * from core/actions.ts in Phase 4 of docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; the
+ * package entry re-exports them.
+ */
+import { builtinActionSpec } from '../../../core/actions.js';
+/**
+ * Classify a document into a document type (`uipath.document.classify`). The
+ * result publishes `ClassificationResult` — an array of typed classifications
+ * with page ranges and confidences.
+ *
+ * @param inputs - The file reference and optional page range / split / model settings.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export function documentClassify(inputs) {
+    return builtinActionSpec({ kind: 'documentClassify', inputs });
+}
+/**
+ * Extract fields from a document with an INLINE schema — Dynamic Extract
+ * (`uipath.ixp.extract-document-builder`), the newer of the two extraction
+ * shapes. No deployed IXP project is referenced: the extraction schema rides
+ * the node. The result publishes `ExtractionResult` (and `Taxonomy`).
+ *
+ * @param inputs - The file reference, the inline extraction schema, and
+ * optional page range / model settings.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export function dynamicExtract(inputs) {
+    return builtinActionSpec({ kind: 'dynamicExtract', inputs });
+}

package/dist/nodes/document/flow/family.d.ts

@@ -0,0 +1,3 @@
+/** The document node family, as flow-node-registry.ts lists it: Document Classify and Dynamic Extract. */
+import type { FlowNodeFamily } from '../../../flow-node-type.js';
+export declare const documentFlowFamily: FlowNodeFamily;

package/dist/nodes/document/flow/family.js

@@ -0,0 +1,7 @@
+import { documentClassifyNodeType, DOCUMENT_DIAGNOSTICS, dynamicExtractNodeType } from './node-type.js';
+export const documentFlowFamily = {
+    id: 'document',
+    title: 'Document understanding',
+    types: [documentClassifyNodeType, dynamicExtractNodeType],
+    diagnostics: DOCUMENT_DIAGNOSTICS,
+};

package/dist/nodes/document/flow/index.d.ts

@@ -0,0 +1,3 @@
+/** The document family's public surface, which the package entry re-exports. */
+export * from './spec.js';
+export * from './factories.js';

package/dist/nodes/document/flow/index.js

@@ -0,0 +1,3 @@
+/** The document family's public surface, which the package entry re-exports. */
+export * from './spec.js';
+export * from './factories.js';

package/dist/nodes/document/flow/node-type.d.ts

@@ -0,0 +1,14 @@
+import type { DiagnosticCatalog } from '../../../core/nodes/family.js';
+import type { FlowNodeType } from '../../../flow-node-type.js';
+import type { DocumentClassifyInputs, DynamicExtractInputs } from './spec.js';
+export type DocumentClassifySpec = {
+    kind: 'documentClassify';
+    inputs: DocumentClassifyInputs;
+};
+export type DynamicExtractSpec = {
+    kind: 'dynamicExtract';
+    inputs: DynamicExtractInputs;
+};
+export declare const DOCUMENT_DIAGNOSTICS: DiagnosticCatalog;
+export declare const documentClassifyNodeType: FlowNodeType<DocumentClassifySpec>;
+export declare const dynamicExtractNodeType: FlowNodeType<DynamicExtractSpec>;

package/dist/nodes/document/flow/node-type.js

@@ -0,0 +1,150 @@
+/**
+ * The two document node types: Document Classify (`uipath.document.classify@1.0`)
+ * and Dynamic Extract (`uipath.ixp.extract-document-builder@1.0.0`). Moved from
+ * serialize.ts / check.ts / decompile.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; serialized output, printed source,
+ * codes and messages unchanged.
+ *
+ * Not here: `ixpExtract()` (`uipath.ixp.<project type>`), whose type name comes
+ * from the model rather than being one fixed name, which the contract does not
+ * express yet.
+ */
+import { toExpr } from '../../../core/expr.js';
+import { jsonClone } from '../../../core/json-file.js';
+export const DOCUMENT_DIAGNOSTICS = {
+    DOC_NO_FILEREF: { severity: 'error', summary: 'no fileRef, so nothing to classify or extract from' },
+    EXTRACT_SCHEMA_SHAPE: { severity: 'error', summary: 'a Dynamic Extract schema that is not an object' },
+};
+function checkFileRef(inputs, verb, ctx) {
+    const fr = inputs.fileRef;
+    const empty = fr === undefined || fr === null || (typeof fr === 'string' && fr.trim() === '');
+    if (empty) {
+        ctx.report('DOC_NO_FILEREF', `"${ctx.step}" has no fileRef — nothing to ${verb}. Reference a file input or an upstream attachment.`);
+    }
+}
+/** The definition's `inputDefaults`, which both nodes spread first. */
+function defaults(typeName, version, ctx) {
+    return jsonClone((ctx.definition(typeName, version)?.inputDefaults) ?? {});
+}
+/** `fileRef`, as the lift reads it: `=js:` text as an Expr, anything else as text. */
+function liftFileRef(node, ctx) {
+    const fr = ctx.sourceText(node.inputs?.fileRef) ?? '';
+    return fr.startsWith('=js:') ? ctx.expr(fr) : fr;
+}
+/** `pageRange` when it is a non-empty string, as the lift reads it. */
+function liftPageRange(node) {
+    const p = node.inputs?.pageRange;
+    return typeof p === 'string' && p !== '' ? p : undefined;
+}
+export const documentClassifyNodeType = {
+    kind: 'documentClassify', typeName: 'uipath.document.classify', version: '1.0', factory: 'documentClassify',
+    definition: 'bundled', rawNode: { factory: 'documentClassify()' },
+    serialize: ({ inputs }, ctx) => {
+        const d = defaults('uipath.document.classify', '1.0', ctx);
+        // Classify follows the default envelope rules for fileRef (unlike the
+        // `uipath.ixp.*` extractors — see migrate's UNWRAPPED_INPUTS).
+        return {
+            inputs: {
+                ...d,
+                fileRef: ctx.render(toExpr(inputs.fileRef)),
+                ...(inputs.pageRange !== undefined ? { pageRange: inputs.pageRange } : {}),
+                ...(inputs.splitPages !== undefined ? { splitPages: inputs.splitPages } : {}),
+                ...(inputs.modelConfig !== undefined
+                    ? { modelConfig: { ...(d.modelConfig ?? {}), ...inputs.modelConfig } }
+                    : {}),
+            },
+        };
+    },
+    deserialize: (node, ctx) => {
+        const pageRange = liftPageRange(node);
+        const split = ctx.plainValue(node.inputs?.splitPages);
+        return {
+            kind: 'documentClassify',
+            inputs: {
+                fileRef: liftFileRef(node, ctx),
+                ...(pageRange !== undefined ? { pageRange } : {}),
+                ...(split === true ? { splitPages: true } : {}),
+            },
+        };
+    },
+    print: ({ inputs }, ctx) => ({
+        factory: 'documentClassify',
+        options: [
+            ['fileRef', ctx.value(inputs.fileRef)],
+            ['pageRange', inputs.pageRange !== undefined ? ctx.string(inputs.pageRange) : undefined],
+            ['splitPages', inputs.splitPages === true ? 'true' : undefined],
+        ],
+    }),
+    check: ({ inputs }, ctx) => checkFileRef(inputs, 'classify', ctx),
+    // check collected no expressions for this kind before the port; unchanged by it.
+    expressions: () => [],
+    output: () => ({ kind: 'opaque' }),
+};
+export const dynamicExtractNodeType = {
+    kind: 'dynamicExtract', typeName: 'uipath.ixp.extract-document-builder', version: '1.0.0', factory: 'dynamicExtract',
+    definition: 'bundled', rawNode: { factory: 'dynamicExtract()' },
+    serialize: ({ inputs }, ctx) => {
+        const d = defaults('uipath.ixp.extract-document-builder', '1.0.0', ctx);
+        const m = inputs.model;
+        return {
+            inputs: {
+                ...d,
+                // The deployment identity Studio Web's panel destructures — both the
+                // nested `model` object and the flat mirrors the definition declares.
+                model: { modelName: m.modelName, folderKey: m.folderKey },
+                modelName: m.modelName,
+                folderKey: m.folderKey,
+                ...(m.projectId !== undefined ? { projectId: m.projectId } : {}),
+                ...(m.projectName !== undefined ? { projectName: m.projectName } : {}),
+                ...(m.folderName !== undefined ? { folderName: m.folderName } : {}),
+                ...(m.versionTag !== undefined ? { versionTag: m.versionTag } : {}),
+                // A `uipath.ixp.*` fileRef must stay a PLAIN `=js:` string — the
+                // platform reads it unwrapped (see migrate's UNWRAPPED_INPUTS).
+                fileRef: ctx.render(toExpr(inputs.fileRef)),
+                ...(inputs.pageRange !== undefined ? { pageRange: inputs.pageRange } : {}),
+                ...(inputs.modelConfig !== undefined
+                    ? { modelConfig: { ...(d.modelConfig ?? {}), ...inputs.modelConfig } }
+                    : {}),
+                ...(inputs.schema !== undefined ? { schemaDocument: inputs.schema } : {}),
+                // The definition's model declares `source: true`: the platform mints a
+                // stable storage slot per instance; omit it and the node validates then
+                // faults. Deterministic, like every other minted identity here.
+                source: ctx.mint('source'),
+            },
+            // IxP instances must NOT carry the manifest's model block — the slim
+            // { type, serviceType } lives only in definitions[] (product validate
+            // rejects a node-level copy). Per call, not `nodeModel`: a rawNode of this
+            // type keeps the model it always had.
+            model: 'omit',
+        };
+    },
+    deserialize: (node, ctx) => {
+        const pageRange = liftPageRange(node);
+        const schema = node.inputs?.schemaDocument;
+        return {
+            kind: 'dynamicExtract',
+            inputs: {
+                fileRef: liftFileRef(node, ctx),
+                ...(schema !== undefined ? { schema: schema } : {}),
+                ...(pageRange !== undefined ? { pageRange } : {}),
+            },
+        };
+    },
+    print: ({ inputs }, ctx) => ({
+        factory: 'dynamicExtract',
+        options: [
+            ['fileRef', ctx.value(inputs.fileRef)],
+            ['schema', inputs.schema !== undefined ? ctx.json(inputs.schema) : undefined],
+            ['pageRange', inputs.pageRange !== undefined ? ctx.string(inputs.pageRange) : undefined],
+        ],
+    }),
+    check: ({ inputs }, ctx) => {
+        checkFileRef(inputs, 'extract from', ctx);
+        if (inputs.schema !== undefined && (typeof inputs.schema !== 'object' || Array.isArray(inputs.schema))) {
+            ctx.report('EXTRACT_SCHEMA_SHAPE', `"${ctx.step}"'s schema must be an object (the inline extraction schema document).`);
+        }
+    },
+    // check collected no expressions for this kind before the port; unchanged by it.
+    expressions: () => [],
+    output: () => ({ kind: 'opaque' }),
+};

package/dist/nodes/document/flow/spec.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The document family's authoring types — Document Classify
+ * (`uipath.document.classify`) and Dynamic Extract
+ * (`uipath.ixp.extract-document-builder`) — and their kinds' entries in
+ * `FlowActionSpecs`. Moved from core/actions.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md.
+ */
+import type { Expr } from '../../../core/expr.js';
+export interface DocumentClassifyInputs {
+    /** The document to classify — a file reference (`input('file')`, `out('fetch', 'fileRef')`, …). */
+    fileRef: string | Expr;
+    /** Page range to classify, e.g. `'1-3'`. Omit for the whole document. */
+    pageRange?: string;
+    /** Split multi-document files into per-type page ranges. */
+    splitPages?: boolean;
+    /** Model configuration overrides; omit for the platform defaults (gemini_2_5_flash). */
+    modelConfig?: Record<string, unknown>;
+}
+export interface DynamicExtractInputs {
+    /** The document to extract from — a file reference. */
+    fileRef: string | Expr;
+    /**
+     * The IXP model deployment the extraction runs against. Dynamic Extract
+     * authors its SCHEMA inline, but execution still needs a model: Studio Web's
+     * panel destructures `modelName` and `folderKey`, and the platform rejects an
+     * instance without them.
+     */
+    model: {
+        /** The deployment's model name, e.g. `'invoiceixp-cef0d447-ixp'`. */
+        modelName: string;
+        /** Folder key (GUID) the deployment lives in. */
+        folderKey: string;
+        /** The IXP project's id (GUID). */
+        projectId?: string;
+        /** The IXP project's display name. */
+        projectName?: string;
+        /** Folder display name. */
+        folderName?: string;
+        /** Deployment version tag; omit for the live version. */
+        versionTag?: string;
+    };
+    /**
+     * The extraction schema (the node's inline taxonomy): a JSON-schema-shaped
+     * document describing the fields to extract. This is the Dynamic Extract
+     * node's defining input — authored inline rather than referencing a deployed
+     * IXP project (use {@link ixpExtract} for those).
+     */
+    schema?: Record<string, unknown>;
+    /** Page range to extract, e.g. `'1-3'`. Omit for the whole document. */
+    pageRange?: string;
+    /** Model configuration overrides; omit for the platform defaults. */
+    modelConfig?: Record<string, unknown>;
+}
+declare module '../../../core/actions.js' {
+    interface FlowActionSpecs {
+        /** The spec {@link documentClassify} builds. */
+        documentClassify: {
+            inputs: DocumentClassifyInputs;
+        };
+        /** The spec {@link dynamicExtract} builds. */
+        dynamicExtract: {
+            inputs: DynamicExtractInputs;
+        };
+    }
+}

package/dist/nodes/document/flow/spec.js

@@ -0,0 +1 @@
+export {};

package/dist/nodes/mock/flow/factories.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The placeholder factory, `mock()`. Moved from core/actions.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; the package entry re-exports it.
+ */
+import { type ActionSpec } from '../../../core/actions.js';
+/**
+ * Declare a PLACEHOLDER step — "a real node goes here later".
+ *
+ * @remarks
+ * A mock takes **no inputs and publishes nothing**. It is a marker on the canvas
+ * that keeps the graph wired and the flow deployable while one step is still
+ * missing — not a stub that returns test data. `out('extractInvoice')` is
+ * refused at compile time (`MOCK_HAS_NO_OUTPUT`) because it would read `null` at
+ * run time, always.
+ *
+ * Say what belongs there in the step's own name and in the label the canvas
+ * shows; the corpus's placeholders read like
+ * `"Extract Invoice Fields (mock — IxP model not yet published)"`.
+ *
+ * ### Why there are no arguments (convention #191 — the family contract)
+ *
+ * The platform's `core.logic.mock@1.0.0` declares **no `inputDefinition`** and one
+ * output whose `source` is the literal `"null"`. Measured over the 4,033 distinct
+ * archived `.flow` artifacts: **74 mock instances in 62 flows, and 0 carrying a
+ * fixture anywhere in the node** — 71 of them with `inputs: {}` or no `inputs`
+ * key. The 3 exceptions carry free-text `placeholder` / `_placeholder` keys the
+ * definition never declares, invented by agents on runs that scored 0.9 and 0.4.
+ *
+ * **This is NOT a local runner's `kind: 'mock'` test construct**, which returns a
+ * baked fixture. They are different things that share
+ * a name, and a `mock({ fixture })` surface would emit a node whose local
+ * behaviour and deployed behaviour disagree silently — see
+ * [#125](https://github.com/UiPath/flow-builder-sdk/issues/125). Nothing this SDK
+ * emits opens that channel: an SDK-authored mock publishes `null` locally,
+ * exactly as the platform does.
+ *
+ * @example
+ * **Hold a step's place until the real node exists**
+ * ```ts
+ * .step('extractInvoice', mock())      // ← swap for the IxP node once the project exists
+ * ```
+ *
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export declare function mock(): ActionSpec;
+declare module '../../../core/actions.js' {
+    interface FlowActionSpecs {
+        /** A placeholder — no inputs, publishes nothing. See {@link mock}. */
+        mock: {};
+    }
+}

package/dist/nodes/mock/flow/factories.js

@@ -0,0 +1,47 @@
+/**
+ * The placeholder factory, `mock()`. Moved from core/actions.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; the package entry re-exports it.
+ */
+import { builtinActionSpec } from '../../../core/actions.js';
+/**
+ * Declare a PLACEHOLDER step — "a real node goes here later".
+ *
+ * @remarks
+ * A mock takes **no inputs and publishes nothing**. It is a marker on the canvas
+ * that keeps the graph wired and the flow deployable while one step is still
+ * missing — not a stub that returns test data. `out('extractInvoice')` is
+ * refused at compile time (`MOCK_HAS_NO_OUTPUT`) because it would read `null` at
+ * run time, always.
+ *
+ * Say what belongs there in the step's own name and in the label the canvas
+ * shows; the corpus's placeholders read like
+ * `"Extract Invoice Fields (mock — IxP model not yet published)"`.
+ *
+ * ### Why there are no arguments (convention #191 — the family contract)
+ *
+ * The platform's `core.logic.mock@1.0.0` declares **no `inputDefinition`** and one
+ * output whose `source` is the literal `"null"`. Measured over the 4,033 distinct
+ * archived `.flow` artifacts: **74 mock instances in 62 flows, and 0 carrying a
+ * fixture anywhere in the node** — 71 of them with `inputs: {}` or no `inputs`
+ * key. The 3 exceptions carry free-text `placeholder` / `_placeholder` keys the
+ * definition never declares, invented by agents on runs that scored 0.9 and 0.4.
+ *
+ * **This is NOT a local runner's `kind: 'mock'` test construct**, which returns a
+ * baked fixture. They are different things that share
+ * a name, and a `mock({ fixture })` surface would emit a node whose local
+ * behaviour and deployed behaviour disagree silently — see
+ * [#125](https://github.com/UiPath/flow-builder-sdk/issues/125). Nothing this SDK
+ * emits opens that channel: an SDK-authored mock publishes `null` locally,
+ * exactly as the platform does.
+ *
+ * @example
+ * **Hold a step's place until the real node exists**
+ * ```ts
+ * .step('extractInvoice', mock())      // ← swap for the IxP node once the project exists
+ * ```
+ *
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export function mock() {
+    return builtinActionSpec({ kind: 'mock' });
+}

package/dist/nodes/mock/flow/family.d.ts

@@ -0,0 +1,3 @@
+/** The placeholder node family, as flow-node-registry.ts lists it: `core.logic.mock`. */
+import type { FlowNodeFamily } from '../../../flow-node-type.js';
+export declare const mockFlowFamily: FlowNodeFamily;

package/dist/nodes/mock/flow/family.js

@@ -0,0 +1,7 @@
+import { mockNodeType } from './node-type.js';
+export const mockFlowFamily = {
+    id: 'mock',
+    title: 'Placeholder',
+    types: [mockNodeType],
+    diagnostics: { MOCK_HAS_NO_OUTPUT: { severity: 'error', summary: "a read of a placeholder's output" } },
+};

package/dist/nodes/mock/flow/index.d.ts

@@ -0,0 +1,2 @@
+/** The placeholder family's public surface, which the package entry re-exports. */
+export * from './factories.js';

package/dist/nodes/mock/flow/index.js

@@ -0,0 +1,2 @@
+/** The placeholder family's public surface, which the package entry re-exports. */
+export * from './factories.js';