@uipath/maestro-builder-sdk 6.18.9 → 6.19.0

package/dist/nodes/data-fabric/flow/spec.d.ts

@@ -0,0 +1,238 @@
+/**
+ * The Flow Data Fabric family's authoring types, and its four kinds' entries in
+ * `FlowActionSpecs` (docs/NODE_TYPE_ARCHITECTURE_DESIGN.md §4.6). Moved from
+ * core/actions.ts in Phase 2c; the family adds its kinds to the map here, by
+ * declaration merging, so `ActionSpec` gains them wherever this module is part of
+ * the program — the package entry re-exports it, so that is everywhere.
+ */
+import type { Expr } from '../../../core/expr.js';
+/**
+ * The comparison operators the Data Fabric query serializer can emit, spelled
+ * exactly as the file carries them.
+ *
+ * @remarks
+ * There is deliberately no `not in`, `not contains`, or null check — the
+ * serializer cannot emit them, and a filter it cannot emit takes the WHOLE
+ * query down rather than dropping one row. `is any of` is the legacy spelling
+ * of `in` and is still read, but author `in`.
+ */
+export type DataFabricOperator = '=' | '!=' | '>' | '>=' | '<' | '<=' | 'contains' | 'starts with' | 'ends with' | 'in';
+/** One filter row on a Data Fabric query — rows AND together unless `or` is set. */
+export interface DataFabricFilter {
+    /**
+     * The entity column to filter on. A dotted related path (`customer.Name`) is
+     * capped at 3 segments and needs the canvas's `_entityFields` snapshot, which
+     * the SDK does not author — keep from-scratch filters on the entity's own
+     * columns.
+     */
+    field: string;
+    /** Comparison operator; `=` when omitted. */
+    operator?: DataFabricOperator;
+    /**
+     * The comparison value. An `Expr` re-evaluates at activation time.
+     *
+     * A choice-set column compares against the choice's numeric `numberId`, never
+     * its label — a label matches nothing.
+     */
+    value: string | Expr;
+    /**
+     * Start a new OR alternative at this row.
+     *
+     * @remarks
+     * The query model is disjunctive — `alt1 OR alt2 OR …`, each alternative an
+     * AND of its own rows — so `or` SPLITS the list rather than joining one row
+     * to the one before it. `[A, B(or), C]` is therefore `A OR (B AND C)`, not
+     * `(A OR B) AND C`; to get the latter, write it out as
+     * `(A AND C) OR (B AND C)`.
+     *
+     * Ignored on the first row, which has no earlier alternative to split from.
+     */
+    or?: boolean;
+}
+/** How a multi-record query orders its rows before the limit is applied. */
+export interface DataFabricSort {
+    /** The column to order by — a real one; a sort on a missing column is not caught by `validate`. */
+    field: string;
+    /** `'asc'` when omitted. */
+    direction?: 'asc' | 'desc';
+}
+/**
+ * Which record a Data Fabric write targets — exactly ONE of the two forms.
+ *
+ * @remarks
+ * `{ byId }` names a record id, literal or expression. `{ fromRead }` names an
+ * earlier {@link dataFabricRead} STEP and reuses the record that step found, so
+ * the id never has to be carried by hand; `check` rejects a name no read step
+ * has. Shared by {@link dataFabricUpdate} and {@link dataFabricDelete} — the
+ * platform gives them the same `recordSource` shape.
+ */
+export type DataFabricRecordRef = {
+    byId: string | Expr;
+    fromRead?: never;
+} | {
+    fromRead: string;
+    byId?: never;
+};
+export interface DataFabricReadInputs {
+    /** The Data Fabric entity's name, e.g. `'Invoices'`. */
+    entity: string;
+    /** Filter rows selecting the record(s) to query. Omit to take everything the entity holds. */
+    filters?: DataFabricFilter[];
+    /**
+     * `'single'` publishes ONE record as the step's `output`; `'multiple'`
+     * publishes the matching records under `output.results`.
+     *
+     * Setting either selects the node's **1.4** definition, which is where
+     * `resultMode` exists at all — the SDK's pinned default is 1.0, the
+     * read-one-record node this family started as. Omit it and nothing changes:
+     * the step stays on 1.0 and reads one record, as it always did.
+     *
+     * A `'single'` read faults only on an OVER-match; zero matches completes
+     * normally and leaves the step's output unresolved, so treat "not found" as a
+     * branch rather than an error.
+     */
+    resultMode?: 'single' | 'multiple';
+    /**
+     * Row cap for a `'multiple'` query. The emitted query ALWAYS carries a limit:
+     * omitting this resolves to 100, and 1000 is a hard ceiling — a larger value
+     * truncates silently, so page with `skip` instead.
+     */
+    limit?: number;
+    /** Rows to skip before the limit — the paging half of `limit`. */
+    skip?: number;
+    /** Order rows before the limit applies. Without it a limited slice is arbitrary. */
+    sort?: DataFabricSort;
+    /** Only these columns. Omit for every column the entity has. */
+    fields?: string[];
+    /**
+     * Folder key (GUID) for a folder-scoped entity — its `folderId` from
+     * `uip df entities list --include-folders`.
+     *
+     * Requires `resourceKey`: `folderKey` alone serializes the folder as a
+     * source-org LITERAL, which looks portable and breaks on cross-org deploy, so
+     * `check` refuses the pair being half-authored.
+     */
+    folderKey?: string;
+    /**
+     * The key the entity's reference is registered under in the solution, from
+     * `uip solution resources list --kind Entity`.
+     *
+     * @remarks
+     * Only meaningful with `folderKey`. Supplying both emits the two
+     * `resource: 'Entity'` binding rows (`propertyAttribute` `name` and
+     * `folderKey`) that let the flow deploy to another org. Nothing mints this
+     * key for a hand-authored flow — if you cannot resolve one, keep the entity
+     * tenant-scoped and omit both.
+     */
+    resourceKey?: string;
+}
+export interface DataFabricCreateInputs {
+    /** The Data Fabric entity's name, e.g. `'Invoices'`. */
+    entity: string;
+    /**
+     * The columns the new record starts with, by field name. At least one is
+     * required — the node's schema rejects an empty field list rather than
+     * inserting a blank row.
+     */
+    values: Record<string, string | Expr>;
+    /**
+     * Folder key (GUID) for a folder-scoped entity — its `folderId` from
+     * `uip df entities list --include-folders`.
+     *
+     * Requires `resourceKey`: `folderKey` alone serializes the folder as a
+     * source-org LITERAL, which looks portable and breaks on cross-org deploy, so
+     * `check` refuses the pair being half-authored.
+     */
+    folderKey?: string;
+    /**
+     * The key the entity's reference is registered under in the solution, from
+     * `uip solution resources list --kind Entity`.
+     *
+     * @remarks
+     * Only meaningful with `folderKey`. Supplying both emits the two
+     * `resource: 'Entity'` binding rows (`propertyAttribute` `name` and
+     * `folderKey`) that let the flow deploy to another org. Nothing mints this
+     * key for a hand-authored flow — if you cannot resolve one, keep the entity
+     * tenant-scoped and omit both.
+     */
+    resourceKey?: string;
+}
+export interface DataFabricUpdateInputs {
+    /** The Data Fabric entity's name, e.g. `'Invoices'`. */
+    entity: string;
+    /** Which record to update — see {@link DataFabricRecordRef}. */
+    record: DataFabricRecordRef;
+    /**
+     * The columns to write, by field name. An empty string is a real write — it
+     * clears the column.
+     */
+    set: Record<string, string | Expr>;
+    /**
+     * Folder key (GUID) for a folder-scoped entity — its `folderId` from
+     * `uip df entities list --include-folders`.
+     *
+     * Requires `resourceKey`: `folderKey` alone serializes the folder as a
+     * source-org LITERAL, which looks portable and breaks on cross-org deploy, so
+     * `check` refuses the pair being half-authored.
+     */
+    folderKey?: string;
+    /**
+     * The key the entity's reference is registered under in the solution, from
+     * `uip solution resources list --kind Entity`.
+     *
+     * @remarks
+     * Only meaningful with `folderKey`. Supplying both emits the two
+     * `resource: 'Entity'` binding rows (`propertyAttribute` `name` and
+     * `folderKey`) that let the flow deploy to another org. Nothing mints this
+     * key for a hand-authored flow — if you cannot resolve one, keep the entity
+     * tenant-scoped and omit both.
+     */
+    resourceKey?: string;
+}
+export interface DataFabricDeleteInputs {
+    /** The Data Fabric entity's name, e.g. `'Invoices'`. */
+    entity: string;
+    /** Which record to delete — see {@link DataFabricRecordRef}. */
+    record: DataFabricRecordRef;
+    /**
+     * Folder key (GUID) for a folder-scoped entity — its `folderId` from
+     * `uip df entities list --include-folders`.
+     *
+     * Requires `resourceKey`: `folderKey` alone serializes the folder as a
+     * source-org LITERAL, which looks portable and breaks on cross-org deploy, so
+     * `check` refuses the pair being half-authored.
+     */
+    folderKey?: string;
+    /**
+     * The key the entity's reference is registered under in the solution, from
+     * `uip solution resources list --kind Entity`.
+     *
+     * @remarks
+     * Only meaningful with `folderKey`. Supplying both emits the two
+     * `resource: 'Entity'` binding rows (`propertyAttribute` `name` and
+     * `folderKey`) that let the flow deploy to another org. Nothing mints this
+     * key for a hand-authored flow — if you cannot resolve one, keep the entity
+     * tenant-scoped and omit both.
+     */
+    resourceKey?: string;
+}
+declare module '../../../core/actions.js' {
+    interface FlowActionSpecs {
+        /** The spec {@link dataFabricRead} builds. */
+        dataFabricRead: {
+            inputs: DataFabricReadInputs;
+        };
+        /** The spec {@link dataFabricCreate} builds. */
+        dataFabricCreate: {
+            inputs: DataFabricCreateInputs;
+        };
+        /** The spec {@link dataFabricUpdate} builds. */
+        dataFabricUpdate: {
+            inputs: DataFabricUpdateInputs;
+        };
+        /** The spec {@link dataFabricDelete} builds. */
+        dataFabricDelete: {
+            inputs: DataFabricDeleteInputs;
+        };
+    }
+}

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

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

package/dist/nodes/data-fabric/flow/verbs.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The four Flow Data Fabric verbs as node types: read (1.0 and 1.4), create
+ * (1.3), update (1.0 and 1.3) and delete (1.3). Each version's implementation is
+ * the same code today — the serialized shape is identical across the bundled
+ * versions — so a version is one `verb(version)` call; a version that changes the
+ * shape gets its own implementation (design §7).
+ */
+import type { DataFabricCreateInputs, DataFabricDeleteInputs, DataFabricReadInputs, DataFabricUpdateInputs } from './spec.js';
+import type { FlowNodeType, FlowVersionedNodeType } from '../../../flow-node-type.js';
+export type DataFabricReadSpec = {
+    kind: 'dataFabricRead';
+    inputs: DataFabricReadInputs;
+};
+export type DataFabricCreateSpec = {
+    kind: 'dataFabricCreate';
+    inputs: DataFabricCreateInputs;
+};
+export type DataFabricUpdateSpec = {
+    kind: 'dataFabricUpdate';
+    inputs: DataFabricUpdateInputs;
+};
+export type DataFabricDeleteSpec = {
+    kind: 'dataFabricDelete';
+    inputs: DataFabricDeleteInputs;
+};
+export declare const dataFabricRead: FlowVersionedNodeType<DataFabricReadSpec>;
+export declare const dataFabricCreate: FlowNodeType<DataFabricCreateSpec>;
+export declare const dataFabricUpdate: FlowVersionedNodeType<DataFabricUpdateSpec>;
+export declare const dataFabricDelete: FlowNodeType<DataFabricDeleteSpec>;

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;