@uipath/maestro-builder-sdk 6.21.2 → 6.22.0

package/dist/core/actions.d.ts

@@ -10,141 +10,6 @@
 import type { Expr } from './expr.js';
 import type { LookupToken } from './lookups.js';
 import { type ConnectorDescriptor, type TriggerDescriptor } from './connectors.js';
-/** One conditional response branch on an HTTP node — a designer-visible side exit. */
-export interface HttpBranch {
-    /**
-     * The branch's name — it becomes the node's `branch-<name>` source port, so
-     * keep it port-safe (letters, digits, `_`, `-`). Route it with
-     * `.stepToList('branch-<name>', ...)` after the step; the main path continues
-     * from the default port as always.
-     */
-    name: string;
-    /**
-     * When to take this exit, evaluated against the response — e.g.
-     * js-tagged: `$vars.fetch.output.statusCode === 429`. Branches are checked in
-     * order; the first truthy one wins, else the default port fires.
-     */
-    condition: Expr;
-}
-interface HttpInputsBase {
-    /**
-     * Conditional response branches — extra source ports (`branch-<name>`)
-     * beside the default. See {@link HttpBranch}; both HTTP node families
-     * declare them.
-     */
-    branches?: HttpBranch[];
-    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    url: string | Expr;
-    headers?: Record<string, string | Expr>;
-    query?: Record<string, string | Expr>;
-    body?: string | Expr;
-    contentType?: string;
-    /**
-     * Choose the HTTP node explicitly. `false` emits the standalone
-     * `core.action.http`; `true` emits the managed `core.action.http.v2`, routed
-     * through Integration Service's HTTP connector.
-     *
-     * This has no default because these are different platform nodes, not two
-     * modes of one node. A silent `false` made an omitted field compile and
-     * validate as the wrong node while changing failure routing and connection
-     * behavior.
-     *
-     * It is not a version bump, it changes two things you can see:
-     *
-     * - **a 4xx/5xx FAILS the step**, so `.onError(…)` fires on it. On the plain
-     *   node the same 404 comes back on the SUCCESS path as
-     *   `out('fetch','statusCode')` and no error handler ever runs — which is why
-     *   an error port only makes sense here (`check` says so: HTTP_ONERROR_V1).
-     *   The handler can answer the flow (`.return`), stop the run
-     *   (`.terminate`), or compensate and continue at a step the success path
-     *   also reaches (`h.stepToRef('<step>')` — see `references/error-handling.md`);
-     * - both nodes expose JSON responses as parsed values in the live product;
-     *   use `returns` to declare fields before reading them. The node choice does
-     *   not decide whether application/json is parsed.
-     *
-     * With `managed: true`, omit `connection` and `folder` for the platform's
-     * manual/implicit mode, or provide both symbolic names to reuse an Integration
-     * Service HTTP connection. A local run remains unauthenticated.
-     *
-     * @enforcedBy HTTP_ONERROR_V1 `.onError()` on an http step needs `managed: true`; on
-     * the standalone node a 4xx arrives on the SUCCESS path and no handler runs.
-     */
-    managed: boolean;
-    /**
-     * The response BODY's top-level fields and their types — e.g.
-     * `{ items: 'array' }`. Required for either HTTP node if anything reads a
-     * field off a parsed JSON body.
-     *
-     * Why you have to say: the platform's own definition declares the response as
-     * a bare object, because only the API being called knows its shape. Without
-     * this, `out('fetch','body','items')` reads from an object with no declared
-     * fields, and nothing downstream can tell a real field from a typo. Same rule,
-     * and the same word, as
-     * `rpaWorkflow`'s `returns`.
-     *
-     * **Where a declared field is read:** under `body`, never beside it. The
-     * response is an envelope — `{ body, statusCode, headers }` — and these are the
-     * body's fields, so `returns: { items: 'array' }` is read as
-     * `out('fetch', 'body.items')`, which is `$vars.fetch.output.body.items`.
-     * `$vars.fetch.output.items` is undefined at run time.
-     *
-     * @enforcedBy HTTP_READ_UNKNOWN_FIELD A read must be `output.body.<declared field>`,
-     * `output.statusCode` or `output.headers`.
-     * @enforcedBy HTTP_READ_WITHOUT_RETURNS Reading a body field requires declaring it here.
-     */
-    returns?: Record<string, ReturnFieldType>;
-    /**
-     * How long to wait for the response before giving up, as an **ISO-8601
-     * duration** — `'PT30S'` is "give up after 30 seconds", `'PT1M'` one minute,
-     * `'PT15M'` fifteen.
-     *
-     * Both http node types carry this, and both definitions declare the same
-     * default (`PT15M`), so leaving it unset is not "no timeout" — it is fifteen
-     * minutes. Omitted from the emitted node unless you set it, which keeps a flow
-     * that doesn't care byte-identical to the platform's own default shape (~99%
-     * of the 808 deployed http nodes are on the defaults).
-     *
-     * `check` rejects a string the platform cannot parse as a duration —
-     * `'30s'`, `'PT'` and `'30'` are all errors that name the expected form.
-     *
-     * @defaultValue `'PT15M'`
-     * @enforcedBy HTTP_TIMEOUT_NOT_DURATION Must be an ISO-8601 duration.
-     */
-    timeout?: string;
-    /**
-     * How many times to RETRY a retryable failure (5xx, 429, a network error) —
-     * `0`, the definitions' default, means "try once, don't retry". `2` means up
-     * to three attempts in total.
-     *
-     * Must be a non-negative integer. Above **5** `check` warns rather than
-     * errors: the deployed corpus's
-     * largest author-set value is 3, and the platform's own ceiling is not
-     * measured — so a bigger number may well work, and refusing it outright would
-     * fence off something we have no evidence is wrong.
-     *
-     * @defaultValue `0`
-     * @enforcedBy HTTP_RETRY_COUNT_INVALID Must be a non-negative integer.
-     */
-    retryCount?: number;
-}
-export type HttpInputs = HttpInputsBase & ({
-    managed: false;
-    connection?: never;
-    folder?: never;
-} | {
-    managed: true;
-    /** Symbolic HTTP connection name declared in bindings.json. */
-    connection?: string;
-    /** Symbolic folder name declared in bindings.json. */
-    folder?: string;
-    /**
-     * Connector key whose authentication the HTTP proxy should reuse.
-     * Defaults to `uipath-uipath-http`. Set this for a connector-specific
-     * fallback endpoint, for example `uipath-salesforce-slack`.
-     * Requires both `connection` and `folder`.
-     */
-    targetConnector?: string;
-});
 export interface ConnectorOpts {
     /** Connector action version (defaults to the library's newest match). */
     version?: string;
@@ -1928,10 +1793,6 @@ export interface ContextIndexRef {
  * whole body rather than an inputs payload.
  */
 export interface FlowActionSpecs {
-    /** The spec {@link http} builds. */
-    http: {
-        inputs: HttpInputs;
-    };
     /** The spec {@link hitl} builds. */
     hitl: {
         inputs: HitlInputs;
@@ -2059,14 +1920,6 @@ export declare function builtinActionSpec<S extends object>(spec: S): S;
  * @returns The same spec, as a `FlowTrigger` instance.
  */
 export declare function builtinTriggerSpec<S extends object>(spec: S): S;
-/**
- * Declare an HTTP request action, explicitly choosing standalone or managed.
- *
- * @param inputs - The request: `url`, `method`, `body`, the response fields you
- * read back via `returns`, and the `managed` node choice.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export declare function http(inputs: HttpInputs): ActionSpec;
 /**
  * Declare a human task — a step that pauses for a person to read some values,
  * fill others in, and press one of the outcome buttons.

package/dist/core/actions.js

@@ -88,21 +88,6 @@ export function builtinActionSpec(spec) {
 export function builtinTriggerSpec(spec) {
     return new BuiltinTrigger(spec);
 }
-/**
- * Declare an HTTP request action, explicitly choosing standalone or managed.
- *
- * @param inputs - The request: `url`, `method`, `body`, the response fields you
- * read back via `returns`, and the `managed` node choice.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function http(inputs) {
-    if (typeof inputs.managed !== 'boolean') {
-        throw new Error('http() requires managed: true or managed: false because they emit different platform nodes. '
-            + 'Use true for Managed HTTP Request/core.action.http.v2 or when non-2xx statuses must reach .onError(); '
-            + 'use false for the standalone core.action.http node.');
-    }
-    return builtinActionSpec({ kind: 'http', inputs });
-}
 /**
  * Declare a human task — a step that pauses for a person to read some values,
  * fill others in, and press one of the outcome buttons.

package/dist/core/expr.d.ts

@@ -196,7 +196,7 @@ export type ErrorEnvelopeField = 'code' | 'message' | 'detail' | 'category' | 's
  *
  * So the author writes one shape, `.error.<field>`, and `serialize` rewrites it
  * to `.output.<field>` for the one family that publishes it there
- * (`ERROR_ENVELOPE_VAR` in `serialize.ts`). Do not hand-write either prefix: which
+ * (a node type's `errorEnvelope`). Do not hand-write either prefix: which
  * one is right is not a property of the expression, it is a property of the node
  * the step happens to be, and only the builder knows that.
  *

package/dist/core/expr.js

@@ -209,7 +209,7 @@ export function ran(step) {
  *
  * So the author writes one shape, `.error.<field>`, and `serialize` rewrites it
  * to `.output.<field>` for the one family that publishes it there
- * (`ERROR_ENVELOPE_VAR` in `serialize.ts`). Do not hand-write either prefix: which
+ * (a node type's `errorEnvelope`). Do not hand-write either prefix: which
  * one is right is not a property of the expression, it is a property of the node
  * the step happens to be, and only the builder knows that.
  *
@@ -258,7 +258,7 @@ export function ran(step) {
  */
 export function err(step, field) {
     // ONE shape for every family. `serialize` rewrites the prefix for the families
-    // that publish the envelope elsewhere — see `ERROR_ENVELOPE_VAR`.
+    // that publish the envelope elsewhere — see `FlowNodeType.errorEnvelope`.
     return new Expr(`$vars.${step}.error${field ? '.' + field : ''}`);
 }
 /**

package/dist/core/nodes/node-type.d.ts

@@ -45,6 +45,13 @@ export interface OutputRead {
     /** The step whose expression contains the read. */
     reader: string;
 }
+/** A read of a node's output, split where a `reader` contract checks it. */
+export interface OutputPathRead extends OutputRead {
+    /** The first segment after the step (`output`, `error`, …); undefined for a read of the step itself. */
+    field: string | undefined;
+    /** The path after `field`, as the reference spells it (with its leading `.`); `''` when there is none. */
+    rest: string;
+}
 /**
  * How the artifact words a read of a `fields` output: the code prefix its read
  * diagnostics share (`<PREFIX>_READ_NOT_OUTPUT`, `_READ_WITHOUT_RETURNS`,
@@ -65,6 +72,11 @@ export interface FieldsRead {
  * states the fields a read may name — `undefined` when the author declared none,
  * which makes any field read its own mistake — and `read` keeps the wording of
  * the read rule it replaces, for the same reason. `open` admits any field.
+ *
+ * `reader` is for an output whose shape no field list states: an HTTP response is
+ * an envelope (`body`, `statusCode`, `headers`) whose `body` holds the author's
+ * `returns`. The type checks each read itself and reports through its family's
+ * catalog, with the codes it had before the port.
  */
 export type OutputContract = {
     readonly kind: 'none';
@@ -75,6 +87,9 @@ export type OutputContract = {
     readonly fields: Readonly<Record<string, TypeDesc>> | undefined;
     readonly open?: boolean;
     readonly read: FieldsRead;
+} | {
+    readonly kind: 'reader';
+    read(read: OutputPathRead, report: (code: string, message: string, suggestion?: string) => void): void;
 } | {
     readonly kind: 'opaque';
 };

package/dist/core/step-ports.js

@@ -1,14 +1,15 @@
 /**
- * The exits an action declares that the AUTHOR named — a human task's outcomes,
- * an HTTP call's response branches — and the port each one leaves on.
+ * The exits an action declares that the AUTHOR named — a human task's outcomes —
+ * and the port each one leaves on. A registered node type declares its own
+ * (`FlowNodeType.exits`: an HTTP call's response branches); `stepExits` in
+ * flow-step-exits.ts asks it first and falls back here.
  *
  * This is what `.stepSwitch()` routes over, and the reason it exists as a table
- * rather than as two more `if (spec.kind === …)` arms: `serialize` has to turn
+ * rather than as more `if (spec.kind === …)` arms: `serialize` has to turn
  * an arm's `value` into a port, `check` has to say which values are legal and
  * which were left out, and `decompile` has to turn a port back into a value.
- * Those three read the same list here instead of each carrying their own copy
- * of "how a human task names its ports" and "how an HTTP branch names its
- * ports".
+ * Those three read the same list instead of each carrying their own copy of
+ * "how a human task names its ports".
  *
  * `undefined` means the family has no author-declared fan-out at all, which is
  * what makes `.stepSwitch()` on it an error rather than a no-op.
@@ -68,23 +69,6 @@ export function declaredExits(spec, pinnedVersion) {
             ...(e.endsProcess ? { endsProcess: true } : {}),
         }));
     }
-    if (kind === 'http') {
-        const branches = (spec?.inputs?.branches
-            ?? []);
-        if (branches.length === 0) {
-            return {
-                reason: 'it declares no response branches',
-                suggestion: `branches: [{ name: 'rateLimited', condition: … }]`,
-            };
-        }
-        // The fall-through is an exit like any other here — it is what `.switch()`
-        // spells as its default arm, and leaving it out is the same omission as
-        // leaving out a branch.
-        return [
-            ...branches.map((b) => ({ value: String(b?.name ?? ''), port: `branch-${b?.name ?? ''}` })),
-            { value: 'default', port: 'default', isDefault: true },
-        ];
-    }
     return {
         reason: `a ${kind ?? 'custom'} step declares no author-named exits`,
         suggestion: 'Use .step(); route failures with .onError().',

package/dist/core/typed-raw-node.js

@@ -21,8 +21,6 @@ import { ownEntry } from './own-entry.js';
  * themselves (the Data Fabric verbs, since Phase 3).
  */
 export const TYPED_FACTORIES = {
-    'core.action.http': { factory: 'http({ managed: false })' },
-    'core.action.http.v2': { factory: 'http({ managed: true })' },
     'core.control.end': { factory: '.return()' },
     'core.logic.decision': { factory: '.branch()' },
     'core.logic.dowhile': { factory: '.doWhile(name, condition, body, { limit, breakEnabled })' },

package/dist/decompile.js

@@ -38,6 +38,7 @@ import { commentText } from './core/comment-text.js';
 import { tsLiteral, tsNumber, tsText } from './core/ts-literal.js';
 import { contextIndexSlug, parseContextIndexType } from './core/context-index.js';
 import { wireExprBody } from './core/wire-expr.js';
+import { hasExits } from './core/step-ports.js';
 import { parseIxpProjectType } from './core/actions.js';
 import { readFlowGlobals } from './flow-variables.js';
 import { outputBackingGlobal, outputBackingName } from './flow-output-backing.js';
@@ -236,8 +237,6 @@ const T = {
     triggerVoice: 'core.trigger.voice',
     createOutgoingCall: 'uipath.conversational.voice.create-outgoing-call',
     endCall: 'uipath.conversational.voice.end-call',
-    http: 'core.action.http',
-    httpV2: 'core.action.http.v2',
     decision: 'core.logic.decision',
     switch: 'core.logic.switch',
     merge: 'core.logic.merge',
@@ -547,21 +546,29 @@ function specValue(raw) {
     return raw;
 }
 /**
- * Print a node whose type is registered (flow-node-registry.ts): the node type
- * deserializes it to its spec and prints the factory call. A node at a version
- * the type does not register is lifted by its default version's implementation —
- * as every built-in family lifts any version — and `verClause` omits a
- * `{ version }` the type does not register, with a warning. `undefined` when the type is not registered, or the node type declines
- * the node; the caller's branches take it from there.
+ * The registered implementation a node of this type and version lifts with: its
+ * own version's, else the type's default (as every built-in family lifts any
+ * version); undefined when the type is not registered.
  */
-function emitRegisteredSpec(node, imp, inputNames) {
+function registeredImpl(node) {
     const entry = typeof node.type === 'string' ? FLOW_NODE_TYPES.byTypeName(node.type) : undefined;
     if (!entry)
         return undefined;
     const version = String(node.typeVersion ?? '');
-    const impl = (Object.hasOwn(entry.type.versions, version)
+    return (Object.hasOwn(entry.type.versions, version)
         ? entry.type.versions[version]
         : entry.type.versions[entry.type.defaultVersion]);
+}
+/**
+ * A node of a registered type (flow-node-registry.ts), lifted to its spec by the
+ * type's own `deserialize`: undefined when the type is not registered or declines
+ * the node. A node at a version the type does not register is lifted by its
+ * default version's implementation, as every built-in family lifts any version.
+ */
+function liftRegistered(node, impl = registeredImpl(node)) {
+    if (!impl)
+        return undefined;
+    const version = String(node.typeVersion ?? '');
     const ctx = {
         nodeId: node.id,
         expr: specValue,
@@ -574,8 +581,21 @@ function emitRegisteredSpec(node, imp, inputNames) {
         warn: warnOnce,
     };
     const spec = impl.deserialize(node, ctx);
-    if (spec === undefined)
+    return spec === undefined ? undefined : { impl, spec };
+}
+/**
+ * Print a node whose type is registered (flow-node-registry.ts): the node type
+ * deserializes it to its spec and prints the factory call. A node at a version
+ * the type does not register is lifted by its default version's implementation —
+ * as every built-in family lifts any version — and `verClause` omits a
+ * `{ version }` the type does not register, with a warning. `undefined` when the type is not registered, or the node type declines
+ * the node; the caller's branches take it from there.
+ */
+function emitRegisteredSpec(node, imp, inputNames) {
+    const lifted = liftRegistered(node);
+    if (!lifted)
         return undefined;
+    const { impl, spec } = lifted;
     // A spec value as source, recursing into arrays and plain objects so an Expr
     // nested in one (a filter row's value) prints as the helper an author writes —
     // in the `{ k: v }` / `[a, b]` spelling the hand-written printers use.
@@ -707,10 +727,6 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
                 ['exchangeLimit', num(i.exchangeLimit) === '20' ? undefined : num(i.exchangeLimit)],
             ])})`;
         }
-        case T.http:
-            return emitHttp(node, false, imp, inputNames);
-        case T.httpV2:
-            return emitHttp(node, true, imp, inputNames);
         default:
             // A connector action node: `uipath.connector.<key>.<action>` (but NOT the
             // event nodes `uipath.connector.event.*` / `.trigger.*`, which are triggers).
@@ -767,66 +783,6 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
             return unsupportedSpec(node, imp, o);
     }
 }
-/**
- * Invert an HTTP node. The plain node (`core.action.http`) keeps its request at
- * the top level (`url` / `method` / `headers` / `queryParams` / `body` /
- * `contentType`); the managed node (`core.action.http.v2`) nests the request
- * inside `detail.bodyParameters` and routes through IS. Request settings
- * (`timeout` / `retryCount`) sit at the top level on both. Emitted only-when-off
- * their definition defaults, exactly as serialize writes them, so the round-trip
- * stays minimal. The response schema (`returns`) is a Phase-2 refinement.
- */
-function emitHttp(node, managed, imp, inputNames) {
-    const inputs = node.inputs ?? {};
-    const detail = managed
-        ? (inputs.detail ?? {})
-        : {};
-    const req = managed
-        ? detail.bodyParameters ?? {}
-        : inputs;
-    const method = typeof req.method === 'string' ? req.method : 'GET';
-    const headers = managed ? req.headers : inputs.headers;
-    const query = managed ? req.query : inputs.queryParams;
-    const bodySrc = req.body !== undefined && req.body !== '' ? emitVal(req.body, imp, inputNames) : undefined;
-    const headersSrc = emitValMap(headers, imp, inputNames) || undefined;
-    const querySrc = emitValMap(query, imp, inputNames) || undefined;
-    const contentType = !managed && typeof inputs.contentType === 'string' && inputs.contentType !== 'application/json'
-        ? tsLiteral(inputs.contentType) : undefined;
-    const timeout = typeof inputs.timeout === 'string' && inputs.timeout !== 'PT15M' ? tsLiteral(inputs.timeout) : undefined;
-    const retry = inputs.retryCount !== undefined && Number(inputs.retryCount) !== 0 ? tsNumber(inputs.retryCount) : undefined;
-    const branchRows = Array.isArray(inputs.branches) ? inputs.branches : [];
-    const branchesSrc = branchRows.length
-        ? `[${branchRows.map((b) => {
-            const cond = unwrapSource(b.conditionExpression) ?? '';
-            const expr = emitBareExpr(wireExprBody(cond), imp, inputNames);
-            return `{ name: ${tsText(b.name ?? b.id)}, condition: ${expr} }`;
-        }).join(', ')}]`
-        : undefined;
-    const connectionValue = detail.connectionId ?? detail.connectionResourceId ?? req.connection;
-    const connection = managed && typeof connectionValue === 'string' && connectionValue !== 'ImplicitConnection'
-        ? tsLiteral(connectionValue) : undefined;
-    const folder = managed && typeof detail.connectionFolderKey === 'string' && detail.connectionFolderKey.length > 0
-        ? tsLiteral(detail.connectionFolderKey) : undefined;
-    const targetConnector = managed && typeof req.targetConnector === 'string'
-        && req.targetConnector !== 'uipath-uipath-http'
-        ? tsLiteral(req.targetConnector) : undefined;
-    const spec = opts([
-        ['url', emitVal(req.url ?? '', imp, inputNames)],
-        ['method', method !== 'GET' ? tsLiteral(method) : undefined],
-        ['headers', headersSrc],
-        ['query', querySrc],
-        ['body', bodySrc],
-        ['contentType', contentType],
-        ['managed', boolLit(managed)],
-        ['connection', connection],
-        ['folder', folder],
-        ['targetConnector', targetConnector],
-        ['timeout', timeout],
-        ['retryCount', retry],
-        ['branches', branchesSrc],
-    ]);
-    return `${imp.use('http')}(${spec})`;
-}
 /**
  * Split a connector `nodeType` (`uipath.connector.<key>.<action>`) into key +
  * action. Mirrors `core/connectors.ts`'s `splitConnectorNodeType`.
@@ -2715,9 +2671,9 @@ function outcomeIdsOfNode(node) {
  * The exits a node declares, read back off the EMITTED artifact rather than off
  * an authored spec — `inputs.schema.outcomes` for a base or quick-form human
  * task (the product draws one `outcome-<id>` handle per outcome on both, at
- * every version), `inputs.branches` plus `default` for an HTTP call. The
- * authoring-side twin is `declaredExits` in `core/step-ports.ts`; they answer
- * about different inputs, which is why this is not a call into it.
+ * every version), and a registered type's own `exits` over the spec its lift
+ * recovers (an HTTP call's `inputs.branches` plus `default`). The authoring-side
+ * twin is `stepExits` in `flow-step-exits.ts`.
  */
 function declaredExitsOfNode(node) {
     const inputs = (node.inputs ?? {});
@@ -2729,16 +2685,16 @@ function declaredExitsOfNode(node) {
             return undefined;
         return outcomes.map((o) => ({ value: String(o?.name ?? ''), port: `outcome-${o?.id ?? ''}` }));
     }
-    if (node.type === T.http || node.type === T.httpV2) {
-        const branches = (inputs.branches ?? []);
-        if (branches.length === 0)
-            return undefined;
-        return [
-            ...branches.map((b) => ({ value: String(b?.name ?? ''), port: `branch-${b?.name ?? ''}` })),
-            { value: 'default', port: 'default' },
-        ];
-    }
-    return undefined;
+    // A registered type that declares exits answers from its own spec, lifted off
+    // this node; one that declares none is not lifted at all (this runs per edge).
+    const impl = registeredImpl(node);
+    if (!impl?.exits)
+        return undefined;
+    const lifted = liftRegistered(node, impl);
+    const exits = lifted && impl.exits(lifted.spec);
+    if (!exits || !hasExits(exits))
+        return undefined;
+    return exits.map((e) => ({ value: e.value, port: e.port }));
 }
 /**
  * Split a switch case expression into `<discriminant> === <literal>`, the only

package/dist/flow-node-registry.js

@@ -11,10 +11,11 @@ import { hasBundledDefinition } from './flow-definitions.js';
 import { dataFabricFlowFamily } from './nodes/data-fabric/flow/family.js';
 import { delayFlowFamily } from './nodes/delay/flow/family.js';
 import { documentFlowFamily } from './nodes/document/flow/family.js';
+import { httpFlowFamily } from './nodes/http/flow/family.js';
 import { mockFlowFamily } from './nodes/mock/flow/family.js';
 import { queueFlowFamily } from './nodes/queue/flow/family.js';
 import { scriptFlowFamily } from './nodes/script/flow/family.js';
 import { transformFlowFamily } from './nodes/transform/flow/family.js';
 /** The families, in no significant order. Adding one is the whole of registering it. */
-export const FLOW_NODE_FAMILIES = [dataFabricFlowFamily, delayFlowFamily, documentFlowFamily, mockFlowFamily, queueFlowFamily, scriptFlowFamily, transformFlowFamily];
+export const FLOW_NODE_FAMILIES = [dataFabricFlowFamily, delayFlowFamily, documentFlowFamily, httpFlowFamily, mockFlowFamily, queueFlowFamily, scriptFlowFamily, transformFlowFamily];
 export const FLOW_NODE_TYPES = new NodeTypeRegistry('flow', FLOW_NODE_FAMILIES, { hasBundledDefinition });

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

@@ -14,6 +14,7 @@ import type { VersionedNodeType } from './core/nodes/versioned.js';
 import type { NodeFamily, Placement } from './core/nodes/family.js';
 import type { DefinitionReference, NodeContribution } from './core/node-classes.js';
 import type { CheckOpts } from './check.js';
+import type { DeclaredExit, NoExits } from './core/step-ports.js';
 /**
  * What a Flow node type's `serialize` returns: the node's type-owned fields.
  *
@@ -81,6 +82,28 @@ export interface FlowSerializeContext {
      * pair) or must pick an id that is not taken; add entries through `bind`.
      */
     readonly bindings: ReadonlyMap<string, Readonly<Record<string, unknown>>>;
+    /**
+     * A symbolic `connection` or `folder` label resolved through the flow's
+     * bindings.json, as a connector step's is: a self-referential label throws the
+     * refusal check reports, and a value that cannot be a tenant id is warned about
+     * (`CONNECTION_STUB`). `where` names the site in both, e.g. `managed http "fetch"`.
+     */
+    resolveBinding(name: string, attribute: 'connection' | 'folder', where: string): string;
+    /**
+     * Hoist the Integration Service connection pair a definition's `model`
+     * references (`<bindings.NAME>` for its connection id and folder key), deduped
+     * against the flow's existing entries by name, resource key and attribute. An
+     * unresolved connection still gets its entries (no `default`), so the
+     * definition's references always close.
+     */
+    bindConnection(o: {
+        model: unknown;
+        connectorKey: string;
+        connectionId: string;
+        folderKey?: string;
+        /** The entries' `resourceKey`; defaults to `connectionId`. */
+        resourceKey?: string;
+    }): void;
 }
 /** What `deserialize` may ask of the decompiler, for one serialized node. */
 export interface FlowDeserializeContext {
@@ -146,6 +169,20 @@ export interface FlowCheckContext {
     } | undefined;
     /** The options `check` was called with (the connector-library views among them). */
     readonly options: CheckOpts;
+    /**
+     * Check a step's symbolic `connection` / `folder` labels against bindings.json,
+     * as a connector step's are, reporting `BINDING_SELF_NAME` / `BINDING_UNDECLARED`.
+     * Those codes are the pipeline's, shared by every family that binds a
+     * connection, so they belong to no family catalog. `use` names the connector
+     * the connection must belong to, for the cross-step connection-owner rule.
+     */
+    bindingLabels(where: string, labels: {
+        connection?: unknown;
+        folder?: unknown;
+    }, use?: {
+        id: string;
+        connector: string | undefined;
+    }): void;
 }
 /** What a family-level `check` may ask of the checker. */
 export interface FlowFamilyCheckContext {
@@ -199,6 +236,28 @@ export interface FlowNodeType<Spec> extends NodeType<Spec, FlowNodeContribution,
     readonly nodeModel?: 'definition' | 'omit';
     /** What `rawNode` reports for a raw node of this type. */
     readonly rawNode?: FlowRawNodeAdvice;
+    /**
+     * The runtime variable a failed node's envelope is published under, when it is
+     * not `error`. `err()` writes one shape for every family
+     * (`$vars.<step>.error.<field>`), and serialize rewrites a handler's reads to
+     * this variable.
+     *
+     * Measured on the product, one debug run per family (2026-09-10): six of the
+     * seven families probed publish it as `<step>.error`, which is what the
+     * definitions declare (`outputDefinition.error.var`). The exception is
+     * `core.action.http.v2`, whose `<step>.error` is the boolean `true` and whose
+     * envelope is in `<step>.output` (instance 430d43ad-4583-40c0-8f74-b49d2c4904e4).
+     */
+    readonly errorEnvelope?: string;
+    /**
+     * The exits the AUTHOR named on this step — an HTTP call's response branches,
+     * and the port each leaves on — or why it has none to route. What
+     * `.stepSwitch()` routes over, what an arm's `value` and a `.stepToList` port
+     * are checked against, and what decompile reads a fully wired node back as.
+     * Omitted: the type has no author-declared fan-out. The `error` port is never
+     * one of these (`.onError()` routes it).
+     */
+    exits?(spec: Spec): DeclaredExit[] | NoExits;
 }
 /** A Flow node type with several versions. */
 export type FlowVersionedNodeType<Spec> = VersionedNodeType<Spec, FlowNodeContribution, FlowContexts, FlowNodeType<Spec>>;

package/dist/flow-sdk.d.ts

@@ -21,6 +21,7 @@ export * from './core/actions.js';
 export * from './nodes/data-fabric/flow/index.js';
 export * from './nodes/delay/flow/index.js';
 export * from './nodes/document/flow/index.js';
+export * from './nodes/http/flow/index.js';
 export * from './nodes/mock/flow/index.js';
 export * from './nodes/queue/flow/index.js';
 export * from './nodes/script/flow/index.js';

package/dist/flow-sdk.js

@@ -25,6 +25,7 @@ export * from './core/actions.js';
 export * from './nodes/data-fabric/flow/index.js';
 export * from './nodes/delay/flow/index.js';
 export * from './nodes/document/flow/index.js';
+export * from './nodes/http/flow/index.js';
 export * from './nodes/mock/flow/index.js';
 export * from './nodes/queue/flow/index.js';
 export * from './nodes/script/flow/index.js';

package/dist/flow-step-exits.d.ts

@@ -0,0 +1,12 @@
+import { type DeclaredExit, type NoExits } from './core/step-ports.js';
+/**
+ * The author-declared exits of a step's spec: a registered type's own `exits`,
+ * at the version the step resolves to (its pin, else the type's choice; an
+ * unregistered pin falls back to that choice, as check's other rules do), and
+ * `declaredExits` for a kind not yet registered. `serialize` and `check` ask
+ * here, so they agree on what a port means.
+ */
+export declare function stepExits(spec: {
+    kind?: unknown;
+    inputs?: unknown;
+} | undefined, pinnedVersion?: string): DeclaredExit[] | NoExits;