@uipath/maestro-builder-sdk 6.18.9 → 6.19.0

package/dist/core/actions.js

@@ -1,15 +1,5 @@
 import { splitConnectorNodeType, isTriggerDescriptor, } from './connectors.js';
 import { FlowAction, FlowTrigger } from './node-classes.js';
-/**
- * The operation `type` each variant node must carry — one of, and only.
- *
- * @internal Serializer plumbing; an author states the variant, not the mapping.
- */
-export const VARIANT_OPERATION = {
-    map: 'map',
-    filter: 'filter',
-    'group-by': 'groupBy',
-};
 // ─── Document extraction (uipath.ixp.*) ──────────────────────────────────────
 //
 // The platform's *Extract* node (that is its `display.canvasLabel`): it hands a
@@ -49,18 +39,6 @@ export function parseIxpProjectType(nodeType) {
         return undefined;
     return { slug, versionId: m[1], folderKey: m[2] };
 }
-// ─── Delay (core.logic.delay) ────────────────────────────────────────────────
-/**
- * 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',
-];
 // ── Built-in spec adapters ──────────────────────────────────────────────────
 // Every factory result IS a FlowAction/FlowTrigger instance (design §4.4 pass
 // 1), so `instanceof` can tell an SDK-owned construct from a raw literal. The
@@ -125,64 +103,6 @@ export function http(inputs) {
     }
     return builtinActionSpec({ kind: 'http', inputs });
 }
-/**
- * Declare an inline script action.
- *
- * @param inputs - The JavaScript body (`code`, which must `return`) and what it
- * returns (`returns`).
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function script(inputs) {
-    return builtinActionSpec({ kind: 'script', inputs });
-}
-/**
- * Declare a Transform action — a chain of declarative operations over a
- * collection. Read the result downstream with `out('<step>')`.
- *
- * @remarks
- * For a node that does ONE thing, name the variant — the emitted `.flow` then
- * carries `core.action.transform.filter` and reads as `Filter` in the designer
- * instead of a generic `Transform`:
- *
- * ```ts
- * .step('bigOrders', transform({
- *   variant: 'filter',
- *   collection: v('orders'),
- *   operations: [
- *     { type: 'filter', filters: [{ field: 'amount', condition: 'greater_equal', value: 100 }] },
- *   ],
- * }))
- * ```
- *
- * @example
- * **Filter a collection, then reshape what survives**
- * ```ts
- * .var('catalog', types.array, [
- *   { title: 'Deep Learning', author: 'Goodfellow', difficulty: 9, pages: 800 },
- *   { title: 'Information Theory', author: 'MacKay', difficulty: 7, pages: 540 },
- * ])
- * .step('curate', transform({
- *   collection: v('catalog'),
- *   operations: [
- *     { type: 'filter', operation: 'and', filters: [
- *       { field: 'difficulty', condition: 'greater_than', value: 5 },
- *       { field: 'pages', condition: 'less_than', value: 600 },
- *     ] },
- *     { type: 'map', keepOriginalFields: false, mappings: [
- *       { field: 'title', transformation: 'uppercase' },
- *       { field: 'author' },
- *     ] },
- *   ],
- * }))
- * ```
- *
- * @param inputs - The `collection` to transform and the chain of `operations` to
- * run over it.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function transform(inputs) {
-    return builtinActionSpec({ kind: 'transform', 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.
@@ -374,81 +294,6 @@ export function batchTransform(inputs) {
 export function ixpExtract(inputs) {
     return builtinActionSpec({ kind: 'ixpExtract', inputs });
 }
-/**
- * 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 });
-}
-/**
- * Declare a PLACEHOLDER step — "a real node goes here later".
- *
- * @remarks
- * A mock takes **no inputs and publishes nothing**. It is a marker on the canvas
- * that keeps the graph wired and the flow deployable while one step is still
- * missing — not a stub that returns test data. `out('extractInvoice')` is
- * refused at compile time (`MOCK_HAS_NO_OUTPUT`) because it would read `null` at
- * run time, always.
- *
- * Say what belongs there in the step's own name and in the label the canvas
- * shows; the corpus's placeholders read like
- * `"Extract Invoice Fields (mock — IxP model not yet published)"`.
- *
- * ### Why there are no arguments (convention #191 — the family contract)
- *
- * The platform's `core.logic.mock@1.0.0` declares **no `inputDefinition`** and one
- * output whose `source` is the literal `"null"`. Measured over the 4,033 distinct
- * archived `.flow` artifacts: **74 mock instances in 62 flows, and 0 carrying a
- * fixture anywhere in the node** — 71 of them with `inputs: {}` or no `inputs`
- * key. The 3 exceptions carry free-text `placeholder` / `_placeholder` keys the
- * definition never declares, invented by agents on runs that scored 0.9 and 0.4.
- *
- * **This is NOT a local runner's `kind: 'mock'` test construct**, which returns a
- * baked fixture. They are different things that share
- * a name, and a `mock({ fixture })` surface would emit a node whose local
- * behaviour and deployed behaviour disagree silently — see
- * [#125](https://github.com/UiPath/flow-builder-sdk/issues/125). Nothing this SDK
- * emits opens that channel: an SDK-authored mock publishes `null` locally,
- * exactly as the platform does.
- *
- * @example
- * **Hold a step's place until the real node exists**
- * ```ts
- * .step('extractInvoice', mock())      // ← swap for the IxP node once the project exists
- * ```
- *
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function mock() {
-    return builtinActionSpec({ kind: 'mock' });
-}
 /**
  * Invoke a deployed RPA (robotic process automation) workflow — a classic
  * UI-automation process, published to Orchestrator, run by a robot.
@@ -866,157 +711,6 @@ export function agent(inputs) {
 export function inlineAgent(inputs) {
     return builtinActionSpec({ kind: 'inlineAgent', inputs });
 }
-/**
- * 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 });
-}
-/**
- * Query entity records from Data Fabric (`core.datafabric.read`). The result
- * publishes to the step's `output`; downstream references re-fetch fresh data
- * at activation time (the engine re-runs the query rather than caching).
- *
- * @remarks
- * This node is **read-one AND query-many**, on its 1.4 definition: `resultMode:
- * 'multiple'` publishes the matching records under `output.results`, and the
- * platform renames the node "Query entity records" to say so. The SDK still
- * pins 1.0 — read-one — as the no-`{ version }` default, so passing
- * `resultMode` is what selects 1.4; see {@link DataFabricReadInputs.resultMode}.
- *
- * The native family covers all four CRUD verbs: this one,
- * {@link dataFabricCreate}, {@link dataFabricUpdate} and
- * {@link dataFabricDelete}. What it does NOT cover is get-by-id, a query row
- * limit, file record fields, and entity events — those are operations on the
- * SAME product reached through its Integration Service connector,
- * `uipath-uipath-dataservice` (the tenant displays it as **UiPath Data
- * Fabric**). So a flow that needs one of those still straddles two surfaces,
- * and the connector remains the one surface that covers everything:
- *
- * ```ts
- * .step('byId', connector('uipath-uipath-dataservice', 'get-entity-record-by-id',
- *   { entityName: 'Contracts', recordId: input('id') }, { connection: 'df' }))
- * ```
- *
- * Get-by-id matters for long text. This node is a query even when it reads one
- * record by an `Id` filter, and a Data Service query returns a PREVIEW of a
- * long-text (`MULTILINE_MAX`) field: the first 10,000 characters plus
- * `...[Truncated]`, with no flag in the output. A 15,551-character value comes
- * back as 10,014 characters. When a field may exceed 10,000 characters, read
- * it with `get-entity-record-by-id`, which returns the whole value
- * (flow-builder-sdk#954).
- *
- * A connector operation's body fields come from the entity, so the library
- * cannot carry them: run `uip maestro registry prepare uipath-uipath-dataservice
- * get-entity-record-by-id -f entityName=<Entity>` first.
- * The routing table is in the `data-fabric.md` reference and the parent-field
- * loop in `connector-params.md` — cited by name rather than linked, because this
- * comment renders both into the flat corpus, where those files sit alongside
- * it, and onto the site, where each symbol is its own page and a relative
- * `./data-fabric` resolves to nothing.
- *
- * @param inputs - The entity, optional filter rows, result mode, and folder scope.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function dataFabricRead(inputs) {
-    return builtinActionSpec({ kind: 'dataFabricRead', inputs });
-}
-/**
- * Create an entity record in Data Fabric (`core.datafabric.create`). The new
- * record publishes to the step's `output`, so a following
- * {@link dataFabricUpdate} or {@link dataFabricDelete} can read its id.
- *
- * @remarks
- * `values` must name at least one column — the node's schema rejects an empty
- * field list rather than inserting a blank row, and `check` says so before the
- * platform does. Field names are the ENTITY's, so copy them from the scenario
- * or the tenant; nothing offline can tell a real column from a typo.
- *
- * The published `output` is the record as a query returns it, so a long-text
- * (`MULTILINE_MAX`) field longer than 10,000 characters comes back cut, with
- * `...[Truncated]` appended, even though the whole value was stored. Use the
- * value you passed in, or re-read the record with the connector's
- * `get-entity-record-by-id`, when the whole text is needed (flow-builder-sdk#954).
- *
- * See {@link dataFabricRead} for what the native family still does not cover
- * and which connector operation covers it.
- *
- * @param inputs - The entity, the columns the record starts with, and folder scope.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function dataFabricCreate(inputs) {
-    return builtinActionSpec({ kind: 'dataFabricCreate', inputs });
-}
-/**
- * Update an entity record in Data Fabric (`core.datafabric.update`). Target the
- * record by id or through an earlier {@link dataFabricRead} step; downstream
- * reads of this step observe the record AFTER the write.
- *
- * @remarks
- * `set` must write at least one column: an empty `set` is a no-op the platform
- * reports as success, so `check` rejects it.
- *
- * See {@link dataFabricRead} for what the native family still does not cover
- * and which connector operation covers it.
- *
- * @param inputs - The entity, the record selector, and the columns to write.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function dataFabricUpdate(inputs) {
-    assertOneRecordRef(inputs.record, 'dataFabricUpdate');
-    return builtinActionSpec({ kind: 'dataFabricUpdate', inputs });
-}
-/**
- * Delete an entity record from Data Fabric (`core.datafabric.delete`). Target
- * the record by id or through an earlier {@link dataFabricRead} step, exactly
- * as {@link dataFabricUpdate} does.
- *
- * @remarks
- * A delete **publishes nothing** — its definition declares no output — so
- * `$vars.<step>.output` is undefined at run time and `check` rejects a read of
- * it. Take what you need off the read step that found the record, before the
- * delete.
- *
- * See {@link dataFabricRead} for what the native family still does not cover
- * and which connector operation covers it.
- *
- * @param inputs - The entity, the record selector, and folder scope.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function dataFabricDelete(inputs) {
-    assertOneRecordRef(inputs.record, 'dataFabricDelete');
-    return builtinActionSpec({ kind: 'dataFabricDelete', inputs });
-}
-/**
- * `record` names exactly ONE of `{ byId }` / `{ fromRead }`. Both forms are
- * optional properties on the same object type, so TypeScript alone cannot
- * refuse `{}` — and an empty selector compiles into a write with no target.
- */
-function assertOneRecordRef(record, factory) {
-    const byId = record?.byId !== undefined;
-    const fromRead = typeof record?.fromRead === 'string';
-    if (byId === fromRead) {
-        throw new Error(`${factory}() targets exactly ONE of record: { byId } or record: { fromRead: '<step>' }.`);
-    }
-}
 /**
  * Declare an Orchestrator QUEUE ITEM step.
  *

package/dist/core/error-port.d.ts

@@ -25,3 +25,9 @@ export declare function definitionHasErrorPort(def: any): boolean;
 export declare function errorPortRefusal(stepName: string, def: any, o?: {
     bundled?: boolean;
 }): string;
+/**
+ * The ONERROR_NO_ERROR_PORT sentence for a registered node type whose definition is
+ * built per tenant and which declares no error port (`errorPort: false`), so there
+ * is no definition to name. Shared with serialize, which throws it for the same node.
+ */
+export declare function declaredErrorPortRefusal(stepName: string, typeName: string, version: string): string;

package/dist/core/error-port.js

@@ -34,3 +34,12 @@ export function errorPortRefusal(stepName, def, o = {}) {
         + `handle the node does not have. Handle the failure downstream instead`
         + (o.bundled ? '.' : `, or pass the definition exactly as \`uip maestro flow registry get\` returns it.`);
 }
+/**
+ * The ONERROR_NO_ERROR_PORT sentence for a registered node type whose definition is
+ * built per tenant and which declares no error port (`errorPort: false`), so there
+ * is no definition to name. Shared with serialize, which throws it for the same node.
+ */
+export function declaredErrorPortRefusal(stepName, typeName, version) {
+    return `Step "${stepName}" is a ${typeName}@${version} node, which has no error port, so the edge would leave a `
+        + 'handle the node does not have. Handle the failure downstream instead.';
+}

package/dist/core/node-classes.d.ts

@@ -19,6 +19,10 @@
  *
  * Parity reference: `docs/FLOW_PARITY.md`.
  */
+/**
+ * A diagnostic a node contributes during `check` — surfaced alongside the
+ * built-in rules with the same severities.
+ */
 export interface ContributionDiagnostic {
     /** Stable machine-readable code, SCREAMING_SNAKE by convention. */
     code: string;
@@ -177,66 +181,3 @@ export declare abstract class FlowResource extends FlowNode<never> {
     /** Always `'resource'` for an attached node. */
     get role(): 'resource';
 }
-/**
- * Place a node this SDK has no factory for, carrying its definition verbatim
- * (`uipath.exotic.thing@2.1` and the manifest the platform served for it).
- *
- * @remarks
- * This is the escape hatch the coverage plan requires: an unknown registry
- * definition is expressible without bypassing serializer invariants. The
- * serializer still owns the node's id, label, `typeVersion` and edge wiring; you
- * supply which definition and which inputs, exactly as a hand-written
- * {@link FlowAction} subclass would.
- *
- * It is also what `decompile` emits for a node type it cannot name, so a
- * round trip preserves the node's TYPE and VERSION instead of degrading it to a
- * placeholder:
- *
- * ```ts
- * .step('exotic', rawNode({
- *   nodeType: 'uipath.exotic.thing',
- *   version: '2.1',
- *   manifest: exoticManifest,      // exactly what `registry get` returned
- *   inputs: { where: input('scope') },
- * }))
- * ```
- *
- * `manifest` must be a real definition — an exact copy of what the registry or
- * Workbench serves for that `nodeType@version`. It is not permission to invent
- * one: the platform resolves the node against its own catalog at run time, so a
- * hand-written manifest validates locally and fails on the tenant.
- *
- * Prefer a typed factory when one exists — it carries the family's checks, its
- * defaults, and its output contract, none of which a raw node can know.
- *
- * **Never for a connector.** A `uipath.connector.*` node type is refused by
- * `check` and `compile`: a raw node carries the author's inputs verbatim, so the
- * emitted node has no `inputs.detail` and no connection binding — `validate`
- * only warns ("Connector is not configured") and the run can never reach
- * Integration Service. Use {@link connector}, and `registry prepare` when
- * compile reports an input the static library does not carry; use
- * {@link onEvent} for a connector event trigger.
- *
- * **Prefer the typed factory** for a node type that has one: `check` warns
- * (`RAW_NODE_TYPED_FAMILY`), because `validate` cannot see an input the
- * registry definition does not declare. For a `core.datafabric.*` type, a key
- * the product never reads (an invented `_sortOptions` in place of `_sort`) is
- * an error at a version the SDK bundles (`RAW_NODE_UNKNOWN_INPUT`); the
- * canvas's snapshots, such as the `_entityFields` a related-path filter
- * needs, stay legal.
- *
- * @param spec - The definition to compile against, plus the node's inputs.
- * @returns A node to pass to `.step(...)`.
- */
-export declare function rawNode(spec: {
-    /** The definition's `nodeType`, verbatim. */
-    nodeType: string;
-    /** The exact definition version; also becomes the node's `typeVersion`. */
-    version: string;
-    /** The complete node manifest, exactly as the platform serves it. */
-    manifest: unknown;
-    /** The node's `inputs`. `Expr` values render through the usual pipeline. */
-    inputs?: Record<string, unknown>;
-    /** Overrides for the node's `outputs`; rarely needed. */
-    outputs?: Record<string, unknown>;
-}): FlowAction;

package/dist/core/node-classes.js

@@ -19,12 +19,6 @@
  *
  * Parity reference: `docs/FLOW_PARITY.md`.
  */
-/**
- * A diagnostic a node contributes during `check` — surfaced alongside the
- * built-in rules with the same severities.
- */
-import { connectorRawNodeRefusal } from './connector-raw-node.js';
-import { typedFamilyRawNodeWarning, dataFabricUnknownInputs } from './typed-raw-node.js';
 /**
  * The abstract root of every definition-backed node the builder can place.
  *
@@ -74,109 +68,3 @@ export class FlowResource extends FlowNode {
         return 'resource';
     }
 }
-/**
- * Place a node this SDK has no factory for, carrying its definition verbatim
- * (`uipath.exotic.thing@2.1` and the manifest the platform served for it).
- *
- * @remarks
- * This is the escape hatch the coverage plan requires: an unknown registry
- * definition is expressible without bypassing serializer invariants. The
- * serializer still owns the node's id, label, `typeVersion` and edge wiring; you
- * supply which definition and which inputs, exactly as a hand-written
- * {@link FlowAction} subclass would.
- *
- * It is also what `decompile` emits for a node type it cannot name, so a
- * round trip preserves the node's TYPE and VERSION instead of degrading it to a
- * placeholder:
- *
- * ```ts
- * .step('exotic', rawNode({
- *   nodeType: 'uipath.exotic.thing',
- *   version: '2.1',
- *   manifest: exoticManifest,      // exactly what `registry get` returned
- *   inputs: { where: input('scope') },
- * }))
- * ```
- *
- * `manifest` must be a real definition — an exact copy of what the registry or
- * Workbench serves for that `nodeType@version`. It is not permission to invent
- * one: the platform resolves the node against its own catalog at run time, so a
- * hand-written manifest validates locally and fails on the tenant.
- *
- * Prefer a typed factory when one exists — it carries the family's checks, its
- * defaults, and its output contract, none of which a raw node can know.
- *
- * **Never for a connector.** A `uipath.connector.*` node type is refused by
- * `check` and `compile`: a raw node carries the author's inputs verbatim, so the
- * emitted node has no `inputs.detail` and no connection binding — `validate`
- * only warns ("Connector is not configured") and the run can never reach
- * Integration Service. Use {@link connector}, and `registry prepare` when
- * compile reports an input the static library does not carry; use
- * {@link onEvent} for a connector event trigger.
- *
- * **Prefer the typed factory** for a node type that has one: `check` warns
- * (`RAW_NODE_TYPED_FAMILY`), because `validate` cannot see an input the
- * registry definition does not declare. For a `core.datafabric.*` type, a key
- * the product never reads (an invented `_sortOptions` in place of `_sort`) is
- * an error at a version the SDK bundles (`RAW_NODE_UNKNOWN_INPUT`); the
- * canvas's snapshots, such as the `_entityFields` a related-path filter
- * needs, stay legal.
- *
- * @param spec - The definition to compile against, plus the node's inputs.
- * @returns A node to pass to `.step(...)`.
- */
-export function rawNode(spec) {
-    return new RawNode(spec);
-}
-/** The {@link rawNode} implementation — a snapshot-backed contribution. */
-class RawNode extends FlowAction {
-    spec;
-    constructor(spec) {
-        super();
-        this.spec = spec;
-    }
-    /**
-     * `check` surfaces the connector refusal as an error, a typed family as a
-     * warning, and a Data Fabric key the product never reads as an error at a
-     * bundled version (a warning at any other); `compile` throws the errors
-     * (see {@link contribute}).
-     */
-    diagnostics() {
-        const refusal = connectorRawNodeRefusal(this.spec.nodeType);
-        if (refusal)
-            return [{ code: 'RAW_NODE_CONNECTOR', severity: 'error', message: refusal }];
-        const out = [];
-        const unknown = dataFabricUnknownInputs(this.spec.nodeType, this.spec.version, this.spec.inputs);
-        if (unknown)
-            out.push({ code: 'RAW_NODE_UNKNOWN_INPUT', ...unknown });
-        const typed = typedFamilyRawNodeWarning(this.spec.nodeType);
-        if (typed)
-            out.push({ code: 'RAW_NODE_TYPED_FAMILY', severity: 'warning', message: typed });
-        return out;
-    }
-    contribute(context) {
-        // compile does not run diagnostics(); refuse here too so the escape hatch
-        // cannot emit an unconfigured connector node. (A Data Fabric key the
-        // product never reads is refused by the serializer, for every contribution.)
-        const refusal = connectorRawNodeRefusal(this.spec.nodeType);
-        if (refusal)
-            throw new Error(refusal);
-        const version = context.requestedVersion ?? this.spec.version;
-        if (context.requestedVersion !== undefined && context.requestedVersion !== this.spec.version) {
-            // Versions are exact everywhere in this SDK: a contributor may not
-            // substitute its own for an explicit request (design §2.6).
-            throw new Error(`rawNode("${this.spec.nodeType}") carries version ${this.spec.version}, but the step requests `
-                + `${context.requestedVersion}. Pass the manifest for the requested version, or drop { version }.`);
-        }
-        return {
-            definition: {
-                source: 'snapshot',
-                nodeType: this.spec.nodeType,
-                version,
-                manifest: this.spec.manifest,
-            },
-            ...(this.spec.inputs !== undefined ? { inputs: this.spec.inputs } : {}),
-            ...(this.spec.outputs !== undefined ? { outputs: this.spec.outputs } : {}),
-        };
-    }
-}

package/dist/core/nodes/family.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Node families — node types grouped under one owner (design §3, §4.4).
+ *
+ * A family is organizational: one directory, one CODEOWNERS line, one README for
+ * the developers who work on it, and one catalog of the diagnostic codes its types
+ * emit. Its only behaviour is `check`, for rules that need every placement of the
+ * family at once (a Data Fabric update whose `fromRead` names no read step). A
+ * family object is per artifact, like its node types: Flow's Data Fabric family and
+ * BPMN's are two families that may share a directory and nothing else.
+ */
+import type { ArtifactContexts } from './node-type.js';
+import type { AnyNodeType } from './versioned.js';
+/** Every code a family may emit, with its severity and a one-line summary. */
+export type DiagnosticCatalog = Readonly<Record<string, {
+    readonly severity: 'error' | 'warning';
+    readonly summary: string;
+}>>;
+/** One placed node of a family, as the family-level check sees it. */
+export interface Placement<Spec = unknown> {
+    /** The step name the author gave the node. */
+    readonly step: string;
+    /** The registered kind. */
+    readonly kind: string;
+    readonly spec: Spec;
+    /** The version the node will be emitted at. */
+    readonly version: string;
+}
+export interface NodeFamily<Ctx extends ArtifactContexts> {
+    /** Stable id, e.g. `'data-fabric'`. Unique within the artifact's registry. */
+    readonly id: string;
+    readonly title: string;
+    readonly types: readonly AnyNodeType<Ctx>[];
+    readonly diagnostics: DiagnosticCatalog;
+    /** Rules over every placement of this family's types, after the per-node checks. */
+    check?(placements: readonly Placement[], ctx: Ctx['familyCheck']): void;
+}

package/dist/core/nodes/family.js

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