@uipath/maestro-builder-sdk 6.18.10 → 6.20.0

package/dist/nodes/data-fabric/flow/verbs.js

@@ -0,0 +1,239 @@
+import { applyScope, baseConfig, entityConfigOf, fieldRows, filterRows, liftFields, liftRecord, liftScope, liftValue, printFields, printRecord, scopeOptions, targetRecord, } from './shared.js';
+import { checkCreate, checkRead, checkUpdate, checkWrite } from './check.js';
+import { rawNodeAdvice } from './raw.js';
+/**
+ * Every Data Fabric node carries no node-level `model`, whichever path emits it
+ * (a verb, or a rawNode of its definition). Studio Web never writes one
+ * (flow-core node.ts: "`node.model` is never written"; canvas `nodeToInstance`
+ * omits it), and export seeds it from the definition (services bpmn-to-xml.ts),
+ * so a copy could only go stale. `outputs` stay: the canvas persists them
+ * (`source: '=response'`), and `variables.nodes[]` is derived from them.
+ */
+const NODE_MODEL = 'omit';
+/** The typed spellings RAW_NODE_TYPED_FAMILY names, as core/typed-raw-node.ts wrote them. */
+const READ_ADVICE = rawNodeAdvice('core.datafabric.read', "dataFabricRead({ entity, resultMode: 'single' | 'multiple', filters: [{ field, operator, value, or }], "
+    + 'sort: { field, direction }, limit, skip, fields, folderKey })');
+const CREATE_ADVICE = rawNodeAdvice('core.datafabric.create', 'dataFabricCreate({ entity, values: { <field>: <value> }, folderKey })');
+const UPDATE_ADVICE = rawNodeAdvice('core.datafabric.update', 'dataFabricUpdate({ entity, record: { byId } | { fromRead }, set: { <field>: <value> }, folderKey })');
+const DELETE_ADVICE = rawNodeAdvice('core.datafabric.delete', 'dataFabricDelete({ entity, record: { byId } | { fromRead }, folderKey })');
+/** `{ k: v, … }` from present entries, `''` when none — the decompiler's `opts()`. */
+function obj(entries, ctx) {
+    const parts = entries.filter(([, v]) => v !== undefined).map(([k, v]) => `${ctx.key(k)}: ${v}`);
+    return parts.length ? `{ ${parts.join(', ')} }` : '';
+}
+// ─── read ──────────────────────────────────────────────────────────────────────
+/**
+ * The family's read node grew from "Read entity" into "Query entity records" at
+ * 1.4, and `entityConfig.resultMode` is the input that expresses the difference.
+ * The SDK keeps 1.0 pinned as the default, the same way every other family keeps
+ * its older default — a flow that reads one record must not change version
+ * because the platform moved. So `resultMode` SELECTS 1.4, exactly as a Quartz
+ * `every` selects the scheduled trigger's 1.2.
+ */
+function readAt(version) {
+    return {
+        kind: 'dataFabricRead', typeName: 'core.datafabric.read', version, factory: 'dataFabricRead', definition: 'bundled',
+        nodeModel: NODE_MODEL, rawNode: READ_ADVICE,
+        serialize: ({ inputs }, ctx) => {
+            if (version === '1.0' && inputs.resultMode !== undefined) {
+                throw new Error("dataFabricRead(): { resultMode } needs the node's 1.4 definition, but { version: '1.0' } was "
+                    + 'requested. Drop the version, request 1.4, or drop resultMode.');
+            }
+            const cfg = baseConfig(inputs);
+            // Only 1.4 declares it, and only 1.4 is emitted when it is set (see
+            // `select`) — so writing it can never land on a 1.0 node, where it would
+            // be an input the definition does not know.
+            if (inputs.resultMode !== undefined)
+                cfg.resultMode = inputs.resultMode;
+            if (inputs.limit !== undefined)
+                cfg._recordLimit = inputs.limit;
+            if (inputs.skip !== undefined)
+                cfg._skip = inputs.skip;
+            if (inputs.sort !== undefined)
+                cfg._sort = { field: inputs.sort.field, direction: inputs.sort.direction ?? 'asc' };
+            if (inputs.fields?.length)
+                cfg._selectedFieldNames = [...inputs.fields];
+            if (inputs.filters?.length)
+                cfg._filters = filterRows(inputs.filters, ctx);
+            applyScope(cfg, inputs, ctx);
+            return { inputs: { entityConfig: cfg } };
+        },
+        deserialize: (node) => {
+            const cfg = entityConfigOf(node);
+            const inputs = { ...liftScope(cfg) };
+            const filters = liftFilters(cfg._filters);
+            if (filters.length)
+                inputs.filters = filters;
+            // `resultMode` only exists from 1.4, and recovering it re-selects 1.4 on
+            // the way back out — so a 1.0 node stays a 1.0 node through the round trip.
+            if (cfg.resultMode === 'single' || cfg.resultMode === 'multiple')
+                inputs.resultMode = cfg.resultMode;
+            if (typeof cfg._recordLimit === 'number')
+                inputs.limit = cfg._recordLimit;
+            if (typeof cfg._skip === 'number')
+                inputs.skip = cfg._skip;
+            if (cfg._sort && typeof cfg._sort === 'object') {
+                const sort = cfg._sort;
+                inputs.sort = { field: String(sort.field ?? ''), ...(sort.direction === 'desc' ? { direction: 'desc' } : {}) };
+            }
+            if (Array.isArray(cfg._selectedFieldNames) && cfg._selectedFieldNames.length) {
+                inputs.fields = cfg._selectedFieldNames.map((f) => String(f));
+            }
+            return { kind: 'dataFabricRead', inputs };
+        },
+        print: ({ inputs }, ctx) => {
+            const { entity, tail } = scopeOptions(inputs, ctx);
+            const filterRow = (f) => obj([
+                ['field', ctx.string(f.field)],
+                ['operator', f.operator !== undefined && f.operator !== '=' ? ctx.string(f.operator) : undefined],
+                ['value', ctx.value(f.value)],
+                ['or', f.or ? 'true' : undefined],
+            ], ctx);
+            return {
+                factory: 'dataFabricRead',
+                options: [
+                    entity,
+                    ['filters', inputs.filters?.length ? `[${inputs.filters.map(filterRow).join(', ')}]` : undefined],
+                    ['resultMode', inputs.resultMode !== undefined ? ctx.string(inputs.resultMode) : undefined],
+                    ['limit', inputs.limit !== undefined ? String(inputs.limit) : undefined],
+                    ['skip', inputs.skip !== undefined ? String(inputs.skip) : undefined],
+                    ['sort', inputs.sort !== undefined
+                            ? obj([
+                                ['field', ctx.string(inputs.sort.field)],
+                                ['direction', inputs.sort.direction === 'desc' ? ctx.string('desc') : undefined],
+                            ], ctx)
+                            : undefined],
+                    ['fields', inputs.fields !== undefined ? `[${inputs.fields.map((f) => ctx.string(f)).join(', ')}]` : undefined],
+                    ...tail,
+                ],
+            };
+        },
+        check: ({ inputs }, ctx) => checkRead(inputs, ctx),
+        expressions: ({ inputs }) => (inputs.filters ?? []).map((f) => ({ value: f.value })),
+        output: () => ({ kind: 'opaque' }),
+    };
+}
+/**
+ * `_filters` back as the builder's row list, where `or: true` marks each new OR
+ * alternative. The array is what the platform serializer reads and what compile
+ * writes; the grouped object is the newer authoring shape, tolerated here so a
+ * canvas-authored file still decompiles.
+ */
+function liftFilters(q) {
+    const row = (r, or) => ({
+        field: String(r.field ?? ''),
+        ...(r.operator !== undefined && r.operator !== '=' ? { operator: String(r.operator) } : {}),
+        value: liftValue(r.value),
+        ...(or ? { or: true } : {}),
+    });
+    if (Array.isArray(q))
+        return q.map((r, i) => row(r, i > 0 && r['join'] === 'OR'));
+    if (q && typeof q === 'object') {
+        const g = q;
+        // Grouped: each root row and each group is one alternative, so every one
+        // but the first opens with `or: true`.
+        const alts = [
+            ...(Array.isArray(g.rows) ? g.rows.map((r) => [r]) : []),
+            ...(Array.isArray(g.groups) ? g.groups : [])
+                .map((grp) => (Array.isArray(grp.rows) ? grp.rows : [])),
+        ].filter((a) => a.length);
+        return alts.flatMap((alt, ai) => alt.map((r, ri) => row(r, ai > 0 && ri === 0)));
+    }
+    return [];
+}
+export const dataFabricRead = {
+    kind: 'dataFabricRead', typeName: 'core.datafabric.read', factory: 'dataFabricRead', defaultVersion: '1.0',
+    versions: { '1.0': readAt('1.0'), '1.4': readAt('1.4') },
+    select: ({ inputs }) => (inputs?.resultMode !== undefined ? '1.4' : '1.0'),
+};
+// ─── create ────────────────────────────────────────────────────────────────────
+export const dataFabricCreate = {
+    kind: 'dataFabricCreate', typeName: 'core.datafabric.create', version: '1.3', factory: 'dataFabricCreate',
+    definition: 'bundled', nodeModel: NODE_MODEL, rawNode: CREATE_ADVICE,
+    serialize: ({ inputs }, ctx) => {
+        const cfg = baseConfig(inputs);
+        cfg.fieldValues = fieldRows(inputs.values, ctx);
+        applyScope(cfg, inputs, ctx);
+        return { inputs: { entityConfig: cfg } };
+    },
+    deserialize: (node) => {
+        const cfg = entityConfigOf(node);
+        const scope = liftScope(cfg);
+        return { kind: 'dataFabricCreate', inputs: { ...scope, values: liftFields(cfg.fieldValues) } };
+    },
+    print: ({ inputs }, ctx) => {
+        const { entity, tail } = scopeOptions(inputs, ctx);
+        return { factory: 'dataFabricCreate', options: [entity, ['values', printFields(inputs.values, ctx)], ...tail] };
+    },
+    check: ({ inputs }, ctx) => checkCreate(inputs, ctx),
+    expressions: ({ inputs }) => Object.values(inputs.values ?? {}).map((value) => ({ value })),
+    output: () => ({ kind: 'opaque' }),
+};
+// ─── update ────────────────────────────────────────────────────────────────────
+function updateAt(version) {
+    return {
+        kind: 'dataFabricUpdate', typeName: 'core.datafabric.update', version, factory: 'dataFabricUpdate', definition: 'bundled',
+        nodeModel: NODE_MODEL, rawNode: UPDATE_ADVICE,
+        serialize: ({ inputs }, ctx) => {
+            const cfg = baseConfig(inputs);
+            targetRecord(cfg, inputs.record, ctx);
+            cfg.fieldUpdates = fieldRows(inputs.set, ctx);
+            applyScope(cfg, inputs, ctx);
+            return { inputs: { entityConfig: cfg } };
+        },
+        deserialize: (node) => {
+            const cfg = entityConfigOf(node);
+            const scope = liftScope(cfg);
+            return { kind: 'dataFabricUpdate', inputs: { ...scope, record: liftRecord(cfg), set: liftFields(cfg.fieldUpdates) } };
+        },
+        print: ({ inputs }, ctx) => {
+            const { entity, tail } = scopeOptions(inputs, ctx);
+            return {
+                factory: 'dataFabricUpdate',
+                options: [entity, ['record', printRecord(inputs.record, ctx)], ['set', printFields(inputs.set, ctx)], ...tail],
+            };
+        },
+        check: ({ inputs }, ctx) => checkUpdate(inputs, ctx),
+        expressions: ({ inputs }) => [
+            { value: inputs.record?.byId },
+            ...Object.values(inputs.set ?? {}).map((value) => ({ value })),
+        ],
+        output: () => ({ kind: 'opaque' }),
+    };
+}
+export const dataFabricUpdate = {
+    kind: 'dataFabricUpdate', typeName: 'core.datafabric.update', factory: 'dataFabricUpdate', defaultVersion: '1.0',
+    versions: { '1.0': updateAt('1.0'), '1.3': updateAt('1.3') },
+};
+// ─── delete ────────────────────────────────────────────────────────────────────
+export const dataFabricDelete = {
+    kind: 'dataFabricDelete', typeName: 'core.datafabric.delete', version: '1.3', factory: 'dataFabricDelete',
+    definition: 'bundled', nodeModel: NODE_MODEL, rawNode: DELETE_ADVICE,
+    serialize: ({ inputs }, ctx) => {
+        const cfg = baseConfig(inputs);
+        targetRecord(cfg, inputs.record, ctx);
+        applyScope(cfg, inputs, ctx);
+        return { inputs: { entityConfig: cfg } };
+    },
+    deserialize: (node) => {
+        const cfg = entityConfigOf(node);
+        const scope = liftScope(cfg);
+        return { kind: 'dataFabricDelete', inputs: { ...scope, record: liftRecord(cfg) } };
+    },
+    print: ({ inputs }, ctx) => {
+        const { entity, tail } = scopeOptions(inputs, ctx);
+        return { factory: 'dataFabricDelete', options: [entity, ['record', printRecord(inputs.record, ctx)], ...tail] };
+    },
+    check: ({ inputs }, ctx) => checkWrite(inputs, ctx),
+    expressions: ({ inputs }) => [{ value: inputs.record?.byId }],
+    // A Data Fabric delete is the one verb of the family whose definition declares
+    // no outputDefinition at all — the record is gone, so there is nothing to
+    // publish. Read the record on the step that FOUND it instead, which on the
+    // `{ fromRead }` form is already in the flow.
+    output: () => ({
+        kind: 'none',
+        code: 'DATAFABRIC_DELETE_HAS_NO_OUTPUT',
+        message: ({ node, ref, reader }) => `Delete "${node}" produces no output, but "${ref}" reads one in "${reader}". `
+            + 'A Data Fabric delete declares no outputs — take the value off the dataFabricRead step that found the record, before the delete.',
+    }),
+};

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

@@ -0,0 +1,16 @@
+/**
+ * The Delay family's rules. Moved verbatim from check.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; codes and messages unchanged.
+ */
+import type { DiagnosticCatalog } from '../../../core/nodes/family.js';
+import type { FlowCheckContext } from '../../../flow-node-type.js';
+import { type DelayInputs } from './spec.js';
+export declare const DELAY_DIAGNOSTICS: DiagnosticCatalog;
+/**
+ * Diagnose a `delay` step's wait.
+ *
+ * Rung 1 is the only place an author hears about a bad duration in time to fix
+ * it cheaply. Anything downstream speaks in terms of `timerPreset`/`timerValue`,
+ * the two fields the serializer writes, rather than the one field the author typed.
+ */
+export declare function checkDelay(inputs: DelayInputs | undefined, ctx: FlowCheckContext): void;

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

@@ -0,0 +1,86 @@
+import { DELAY_PRESETS } from './spec.js';
+export const DELAY_DIAGNOSTICS = {
+    DELAY_UNTIL_NOT_ISO: { severity: 'error', summary: '`until` is not an ISO-8601 date-time' },
+    DELAY_NO_DURATION: { severity: 'error', summary: 'no `duration`, so no wait at all' },
+    DELAY_NOT_ISO: { severity: 'error', summary: '`duration` is not an ISO-8601 duration' },
+    DELAY_ZERO: { severity: 'error', summary: 'a zero-length duration' },
+    DELAY_CALENDAR: { severity: 'error', summary: 'a calendar-relative duration no local rung can run' },
+    DELAY_HAS_NO_OUTPUT: { severity: 'error', summary: "a read of a delay's output" },
+};
+/**
+ * An EXACT ISO-8601 duration: weeks/days plus a time part, at least one
+ * component. Copied in shape from the delay definition's own
+ * `timerValue.pattern`, minus the years and months — see DELAY_CALENDAR below.
+ */
+const DURATION_RE = /^P(?!$)(\d+W)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?$/;
+/** Grammatical ISO-8601 duration, including the calendar-relative parts. */
+const ANY_DURATION_RE = /^P(?!$)(\d+Y)?(\d+M)?(\d+W)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?$/;
+/** Natural-language guesses an author might reach for, mapped to a duration. */
+const DURATION_WORDS = [
+    ['second', 'PT30S'], ['minute', 'PT15M'], ['hour', 'PT1H'],
+    ['day', 'P1D'], ['daily', 'P1D'], ['week', 'P1W'], ['weekly', 'P1W'],
+];
+/**
+ * Diagnose a `delay` step's wait.
+ *
+ * Rung 1 is the only place an author hears about a bad duration in time to fix
+ * it cheaply. Anything downstream speaks in terms of `timerPreset`/`timerValue`,
+ * the two fields the serializer writes, rather than the one field the author typed.
+ */
+export function checkDelay(inputs, ctx) {
+    const step = ctx.step;
+    const at = (code, message, suggestion) => ctx.report(code, message, suggestion || undefined);
+    const untilRaw = inputs?.until;
+    if (typeof untilRaw === 'string' && untilRaw.trim() !== '') {
+        // The absolute-date arm: an ISO-8601 date-time, e.g. 2026-09-01T09:00:00Z.
+        const until = untilRaw.trim();
+        if (!/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2})?)?$/.test(until)) {
+            at('DELAY_UNTIL_NOT_ISO', `Delay "${step}"'s until ${JSON.stringify(untilRaw)} is not an ISO-8601 date-time. `
+                + `Use e.g. '2026-09-01T09:00:00Z' (a timezone-less value is read in the tenant's zone).`, `until: '2026-09-01T09:00:00Z'`);
+        }
+        return;
+    }
+    const raw = inputs?.duration;
+    if (raw === undefined || raw === null || (typeof raw === 'string' && raw.trim() === '')) {
+        at('DELAY_NO_DURATION', `Delay "${step}" has no \`duration\`, so it carries no wait at all and the flow runs straight `
+            + `past it. Give it an ISO-8601 duration — ${DELAY_PRESETS.slice(0, 8).join(', ')} … are the `
+            + `designer's presets, and any other exact duration works too.`, `duration: 'PT15M'`);
+        return;
+    }
+    const d = String(raw).trim();
+    if (!ANY_DURATION_RE.test(d)) {
+        at('DELAY_NOT_ISO', `Delay "${step}"'s duration ${JSON.stringify(raw)} is not an ISO-8601 duration. The format is `
+            + `"P" plus a date part and/or "T" plus a time part — PT30S, PT15M, PT2H, P1D, P1W. Note the `
+            + `"T": P1M is a MONTH, PT1M is a minute.`, nearestDuration(d));
+        return;
+    }
+    if (!/[1-9]/.test(d)) {
+        at('DELAY_ZERO', `Delay "${step}"'s duration ${JSON.stringify(d)} is zero-length, so the step waits for no time `
+            + `at all. Use a non-zero duration, or drop the step.`, `duration: 'PT15M'`);
+        return;
+    }
+    // Grammatical, and the platform runs it — but a month is not a fixed number
+    // of milliseconds, so NO local rung can run the flow at all.
+    // Rejected here rather than approximated: guessing 30 days would
+    // put a silent disagreement with the deployed engine back into the pipeline.
+    if (!DURATION_RE.test(d)) {
+        at('DELAY_CALENDAR', `Delay "${step}"'s duration ${JSON.stringify(d)} is calendar-relative: how long a month or a `
+            + `year is depends on when it starts. The platform resolves that at run time, but the local `
+            + `timer takes a fixed millisecond count, so this flow could not be replayed or run offline.`, `duration: 'P30D'`);
+    }
+}
+/** Best guess at what the author meant, for a `DELAY_NOT_ISO` suggestion. */
+function nearestDuration(d) {
+    // The likeliest slip: a time-part duration written without its "T".
+    if (/^P\d+[HMS]$/.test(d) && ANY_DURATION_RE.test(`PT${d.slice(1)}`))
+        return `duration: 'PT${d.slice(1)}'`;
+    const lower = d.toLowerCase();
+    const n = /(\d+)/.exec(lower)?.[1];
+    const word = DURATION_WORDS.find(([w]) => lower.includes(w));
+    if (!word)
+        return undefined;
+    if (!n)
+        return `duration: '${word[1]}'`;
+    const unit = word[1].replace(/\d+/, '');
+    return `duration: '${unit.startsWith('PT') ? `PT${n}${unit.slice(2)}` : `P${n}${unit.slice(1)}`}'`;
+}

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

@@ -0,0 +1,28 @@
+/**
+ * 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 { type ActionSpec } from '../../../core/actions.js';
+import type { DelayInputs } from './spec.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 declare function delay(inputs: DelayInputs): ActionSpec;

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;