@hostwebhook/node-types 1.73.0 → 1.75.0

package/dist/shopify-operations.js

@@ -3,18 +3,24 @@
  * Shopify Admin API operations — single source of truth across the api, the
  * dashboard and downstream consumers (MCP server).
  *
- * ## Four, out of several hundred
+ * ## Ten, out of several hundred
  *
- * The Admin API has hundreds of mutations. This node exposes four, and the
+ * The Admin API has hundreds of mutations. This node exposes ten, and the
  * choice is argued in `api/docs/ADR-0007-shopify.md`: a menu of everything is
- * how a node becomes unusable, and these four cover what people actually
- * automate — put a customer in the store, tag something, sync stock, and read
- * back what the store already knows.
+ * how a node becomes unusable.
  *
- * Product creation and order fulfilment were considered and left out of v1.
- * A product means variants, media and prices; a fulfilment means a location, a
- * fulfilment service and a state machine. Each is a configuration surface of
- * its own, not a field.
+ * The first four cover what people automate on day one — put a customer in the
+ * store, tag something, sync stock, and read back what the store already
+ * knows. The six added on 2026-09-08 cover what they ask for on day two: the
+ * order lifecycle (draft → complete → fulfil → cancel), custom data
+ * (metafields) and putting a product in the catalogue.
+ *
+ * ⚠️ **Every entry below carries the OAuth scope it needs**, in
+ * `SHOPIFY_OPERATION_SCOPES`. That is not documentation: a scope missing from
+ * the credential answers HTTP 403 on a call that looks perfectly formed, and
+ * on Shopify a scope is granted at INSTALL time — adding one to the app means
+ * every existing credential has to be reconnected before it can use the new
+ * operation.
  *
  * ## GraphQL only, and the version is not ours to drift on
  *
@@ -55,15 +61,49 @@
  * `inventoryAdjustQuantities` must be sent with the `@idempotent` directive
  * and an idempotency key. A stock adjustment is the one operation here where a
  * silent retry is a real inventory error, so this is not boilerplate.
+ *
+ * ## What was verified for the six added on 2026-09-08
+ *
+ * Read off the Admin GraphQL reference for the current version, not recalled.
+ * The pages, and the one fact from each that a from-memory version gets wrong:
+ *
+ * - `draftOrderCreate(input: DraftOrderInput!)` — `lineItems` is the only
+ *   required field of the input, and each item is `{ variantId, quantity }`
+ *   OR `{ title, originalUnitPrice, quantity }` for a custom line.
+ * - `draftOrderComplete(id: ID!, …)` — the id is a **sibling argument**, not
+ *   inside an input. `paymentPending` is deprecated and is not offered here.
+ * - `fulfillmentCreate(fulfillment: FulfillmentInput!)` — takes
+ *   `lineItemsByFulfillmentOrder`, NOT an order id. There is no mutation that
+ *   fulfils "an order": fulfilment hangs off FulfillmentOrder, so the
+ *   executor has to look them up first. That indirection is the whole reason
+ *   ADR-0007 left this out of v1.
+ * - `orderCancel(orderId:, reason:, restock:, …)` — `reason` and `restock` are
+ *   **required arguments**, and the payload's errors arrive in
+ *   `orderCancelUserErrors`; plain `userErrors` is deprecated there.
+ * - `metafieldsSet(metafields: [MetafieldsSetInput!]!)` — takes a LIST, and
+ *   each entry needs all of `ownerId`, `namespace`, `key`, `type`, `value`.
+ *   `type` is not guessable from the value: `single_line_text_field` and
+ *   `number_integer` are different metafields.
+ * - `productCreate(product: ProductCreateInput!)` — the argument is `product`,
+ *   not `input`; `input: ProductInput` is the deprecated spelling. It creates
+ *   ONE default variant; more variants are `productVariantsBulkCreate`, which
+ *   is a surface of its own and is not offered here.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SHOPIFY_OPERATION_SPECS = exports.SHOPIFY_SEARCHABLE_RESOURCES = exports.SHOPIFY_TAGGABLE_RESOURCES = exports.SHOPIFY_OPERATIONS = void 0;
+exports.SHOPIFY_OPERATION_SCOPES = exports.SHOPIFY_OPERATION_SPECS = exports.SHOPIFY_PRODUCT_STATUSES = exports.SHOPIFY_CANCEL_REASONS = exports.SHOPIFY_SEARCHABLE_RESOURCES = exports.SHOPIFY_TAGGABLE_RESOURCES = exports.SHOPIFY_OPERATIONS = void 0;
 exports.isShopifyOperation = isShopifyOperation;
+exports.scopesQueFaltanEnShopify = scopesQueFaltanEnShopify;
 exports.SHOPIFY_OPERATIONS = [
     'upsertCustomer',
     'setTags',
     'adjustInventory',
     'findRecords',
+    'createDraftOrder',
+    'completeDraftOrder',
+    'fulfillOrder',
+    'cancelOrder',
+    'setMetafield',
+    'createProduct',
 ];
 /** Type guard — for DTOs and AI tool calls, where the input is untrusted. */
 function isShopifyOperation(value) {
@@ -90,6 +130,27 @@ exports.SHOPIFY_SEARCHABLE_RESOURCES = [
     'customers',
     'products',
 ];
+/**
+ * `OrderCancelReason`, the whole enum, in Shopify's own spelling.
+ *
+ * A dropdown and not free text — and that is the opposite of the call made for
+ * `adjustInventory`'s `reason`, on purpose. The difference is not taste: the
+ * inventory vocabulary was NOT verifiable from the reference (see the note
+ * above), so a dropdown there would have been a list of invented values. This
+ * one IS the enumeration, read off `enums/OrderCancelReason`, and an argument
+ * of type `OrderCancelReason!` rejects anything outside it — so free text here
+ * would only mean the user finds out by failing.
+ */
+exports.SHOPIFY_CANCEL_REASONS = [
+    'CUSTOMER',
+    'DECLINED',
+    'FRAUD',
+    'INVENTORY',
+    'OTHER',
+    'STAFF',
+];
+/** `ProductStatus`, the whole enum. Same reasoning as the cancel reasons. */
+exports.SHOPIFY_PRODUCT_STATUSES = ['ACTIVE', 'DRAFT', 'ARCHIVED'];
 exports.SHOPIFY_OPERATION_SPECS = {
     upsertCustomer: {
         label: 'Add or update customer',
@@ -260,4 +321,348 @@ exports.SHOPIFY_OPERATION_SPECS = {
             },
         ],
     },
+    createDraftOrder: {
+        label: 'Create draft order',
+        description: 'Build an order the merchant can review, invoice or complete. This is the supported way to put an order into a store from outside — it does not charge anybody by itself.',
+        apiRoute: 'mutation draftOrderCreate',
+        params: [
+            {
+                name: 'lineItems',
+                label: 'Line items',
+                type: 'json',
+                required: true,
+                description: 'A JSON array. Each entry is either {"variantId":"gid://shopify/ProductVariant/…","quantity":1} for something in the catalogue, or {"title":"…","originalUnitPrice":"10.00","quantity":1} for a custom line. An empty array is refused by Shopify, not by us.',
+                placeholder: '[{"variantId":"gid://shopify/ProductVariant/1234","quantity":1}]',
+            },
+            {
+                name: 'email',
+                label: 'Customer email',
+                type: 'email',
+                description: 'Who the draft is for, when you do not already have their Shopify id. Ignored if you set a customer id.',
+                placeholder: '{{payload.email}}',
+            },
+            {
+                name: 'customerId',
+                label: 'Customer id',
+                type: 'gid',
+                description: 'gid://shopify/Customer/1234. Wins over the email — with both set, Shopify attaches the draft to this customer.',
+                placeholder: '{{payload.customerId}}',
+            },
+            {
+                name: 'note',
+                label: 'Note',
+                type: 'string',
+                description: 'Internal note, visible to staff in the Shopify admin.',
+            },
+            {
+                name: 'tags',
+                label: 'Tags',
+                type: 'tags',
+                description: 'Tags to put on the draft order.',
+            },
+            {
+                name: 'shippingAddress',
+                label: 'Shipping address',
+                type: 'json',
+                description: 'A JSON object: {"address1":"…","city":"…","province":"…","country":"…","zip":"…"}. Leave empty to let the merchant fill it in.',
+            },
+        ],
+    },
+    completeDraftOrder: {
+        label: 'Complete draft order',
+        description: 'Turn a draft order into a real order. This is the step that reserves stock and can charge — it is not undone by running it again.',
+        apiRoute: 'mutation draftOrderComplete',
+        params: [
+            {
+                name: 'draftOrderId',
+                label: 'Draft order id',
+                type: 'gid',
+                required: true,
+                description: 'gid://shopify/DraftOrder/1234. The create-draft operation puts one in its output, so the usual shape is one node feeding the next.',
+                placeholder: '{{payload.id}}',
+            },
+            {
+                name: 'paymentGatewayId',
+                label: 'Payment gateway id',
+                type: 'gid',
+                description: 'Which gateway processes it. Leave empty to complete the order as pending payment, which is what most automations want.',
+            },
+            {
+                name: 'sourceName',
+                label: 'Source name',
+                type: 'string',
+                description: 'A sales-channel handle, for attribution in the store\'s reports.',
+            },
+        ],
+    },
+    fulfillOrder: {
+        label: 'Fulfil order',
+        description: "Mark an order shipped, optionally with tracking. Fulfils every one of the order's open fulfilment orders.",
+        apiRoute: 'query order.fulfillmentOrders, then mutation fulfillmentCreate (one call per order, all its fulfilment orders in one)',
+        params: [
+            {
+                name: 'orderId',
+                label: 'Order id',
+                type: 'gid',
+                required: true,
+                description: 'gid://shopify/Order/1234. NOT a fulfilment order id — those are looked up from this one, because Shopify has no "fulfil this order" mutation.',
+                placeholder: '{{payload.admin_graphql_api_id}}',
+            },
+            {
+                name: 'trackingNumber',
+                label: 'Tracking number',
+                type: 'string',
+                description: 'Optional. With a number and no carrier, Shopify tries to guess the carrier from the number.',
+                placeholder: '{{payload.tracking_number}}',
+            },
+            {
+                name: 'trackingCompany',
+                label: 'Carrier',
+                type: 'string',
+                description: 'Optional. Shopify builds the tracking link itself for carriers it knows by name.',
+                placeholder: 'DHL Express',
+            },
+            {
+                name: 'trackingUrl',
+                label: 'Tracking URL',
+                type: 'string',
+                description: 'Optional. Only needed for a carrier Shopify does not know — otherwise the number is enough.',
+            },
+            {
+                name: 'notifyCustomer',
+                label: 'Email the customer',
+                type: 'boolean',
+                description: 'Off by default. On sends the shipping confirmation, which is a real email to a real person — the one field here with a consequence outside the store.',
+            },
+        ],
+    },
+    cancelOrder: {
+        label: 'Cancel order',
+        description: 'Cancel an order, optionally restocking it and refunding. Shopify runs this as a background job, so success means "accepted", not "already done".',
+        apiRoute: 'mutation orderCancel',
+        params: [
+            {
+                name: 'orderId',
+                label: 'Order id',
+                type: 'gid',
+                required: true,
+                description: 'gid://shopify/Order/1234.',
+                placeholder: '{{payload.admin_graphql_api_id}}',
+            },
+            {
+                name: 'reason',
+                label: 'Reason',
+                type: 'cancelReason',
+                required: true,
+                description: "Required by Shopify, not by us, and it lands on the order where the merchant reads it. OTHER is the honest answer when none of the others fit.",
+            },
+            {
+                name: 'restock',
+                label: 'Put the stock back',
+                type: 'boolean',
+                description: 'Off by default, which is the safe side: restocking something that never left is how a shelf count goes wrong. Turn it on when the goods really are still there.',
+            },
+            {
+                name: 'notifyCustomer',
+                label: 'Email the customer',
+                type: 'boolean',
+                description: 'Off by default. On sends the cancellation email.',
+            },
+            {
+                name: 'staffNote',
+                label: 'Staff note',
+                type: 'string',
+                description: 'Internal note on the cancellation, for whoever reads it later.',
+            },
+        ],
+    },
+    setMetafield: {
+        label: 'Set a metafield',
+        description: 'Write one piece of custom data onto an order, a customer, a product or a variant — the general way to keep a foreign id or a computed value on a Shopify record.',
+        apiRoute: 'mutation metafieldsSet',
+        params: [
+            {
+                name: 'ownerId',
+                label: 'Owner id',
+                type: 'gid',
+                required: true,
+                description: 'What the metafield hangs off, as a global id — an order, a customer, a product, a variant. A Shopify trigger gives you one in the payload.',
+                placeholder: '{{payload.admin_graphql_api_id}}',
+            },
+            {
+                name: 'namespace',
+                label: 'Namespace',
+                type: 'string',
+                required: true,
+                description: '"custom" is the namespace the Shopify admin shows merchants; anything else is only visible through the API unless a definition exists for it.',
+                placeholder: 'custom',
+            },
+            {
+                name: 'key',
+                label: 'Key',
+                type: 'string',
+                required: true,
+                description: 'The field name inside the namespace.',
+                placeholder: 'external_id',
+            },
+            {
+                name: 'type',
+                label: 'Type',
+                type: 'string',
+                required: true,
+                description: 'The metafield type, e.g. single_line_text_field, number_integer, boolean, json, date. It is NOT inferred from the value — the wrong type is rejected, which is better than silently storing a number as text.',
+                placeholder: 'single_line_text_field',
+            },
+            {
+                name: 'value',
+                label: 'Value',
+                type: 'string',
+                required: true,
+                description: 'Always sent as a string, whatever the type says: Shopify parses it against the type on its side. Setting it again REPLACES what was there.',
+                placeholder: '{{payload.id}}',
+            },
+        ],
+    },
+    createProduct: {
+        label: 'Create product',
+        description: 'Put a product in the catalogue. Creates the product and its one default variant; several variants, prices and media are separate mutations and are not offered here.',
+        apiRoute: 'mutation productCreate',
+        params: [
+            {
+                name: 'title',
+                label: 'Title',
+                type: 'string',
+                required: true,
+                description: 'The only field Shopify insists on.',
+                placeholder: '{{payload.title}}',
+            },
+            {
+                name: 'descriptionHtml',
+                label: 'Description',
+                type: 'string',
+                description: 'HTML, not plain text — line breaks typed here do not survive as line breaks in the storefront.',
+            },
+            {
+                name: 'vendor',
+                label: 'Vendor',
+                type: 'string',
+                description: 'Free text; Shopify does not check it against anything.',
+            },
+            {
+                name: 'productType',
+                label: 'Product type',
+                type: 'string',
+                description: 'Free text, and separate from the store\'s collections.',
+            },
+            {
+                name: 'tags',
+                label: 'Tags',
+                type: 'tags',
+                description: 'Tags to put on the product.',
+            },
+            {
+                name: 'status',
+                label: 'Status',
+                type: 'productStatus',
+                description: 'Left empty, Shopify makes it ACTIVE — visible to shoppers the moment it is created. Pick DRAFT when a person should look at it first.',
+            },
+            {
+                name: 'handle',
+                label: 'Handle',
+                type: 'string',
+                description: 'The URL slug. Left empty, Shopify builds one from the title; set it and a collision fails the whole mutation.',
+            },
+        ],
+    },
 };
+/**
+ * The OAuth scope each operation needs, so a missing one is named BEFORE the
+ * call instead of arriving as an HTTP 403 on a request that looks fine.
+ *
+ * ## The list is "any one of", not "all of"
+ *
+ * That is `fulfillOrder`'s doing and it is not a generalisation for its own
+ * sake: which fulfilment-order scope applies depends on where the order is
+ * fulfilled from — the merchant's own locations, a third-party service, or the
+ * app itself acting as one. Shopify accepts the mutation if the token carries
+ * ANY of the three. Requiring all three would refuse a store that is correctly
+ * set up.
+ *
+ * ## An empty list means "not checkable from the operation alone"
+ *
+ * `setTags` tags an order, a customer or a product through the same mutation,
+ * and `setMetafield` writes onto whichever resource the owner id points at —
+ * so the scope depends on a FIELD, not on the operation. Guessing would be
+ * worse than not checking: a wrong guess blocks a call Shopify would have
+ * accepted, and a pre-flight check that produces false refusals gets deleted.
+ * Those fall through to Shopify's own 403, which `describeShopifyError`
+ * already explains.
+ *
+ * ⚠️ Read against `shopify.dev/docs/api/usage/access-scopes` and each
+ * mutation's own "Access requirements". Two things follow from that page and
+ * are relied on by `scopesQueFaltanEnShopify`:
+ *
+ *   - **A write scope includes read.** `write_orders` grants `read_orders`, so
+ *     a required `read_x` is satisfied by a granted `write_x`.
+ *   - **Scopes are granted at install.** Adding one to the app does not give
+ *     it to credentials that already exist; those have to be reconnected.
+ */
+exports.SHOPIFY_OPERATION_SCOPES = {
+    upsertCustomer: ['write_customers'],
+    /* Depende del recurso elegido, no de la operación. Ver la cabecera. */
+    setTags: [],
+    adjustInventory: ['write_inventory'],
+    /* `findRecords` lee tres colecciones distintas según el recurso. Igual. */
+    findRecords: [],
+    createDraftOrder: ['write_draft_orders'],
+    completeDraftOrder: ['write_draft_orders'],
+    fulfillOrder: [
+        'write_merchant_managed_fulfillment_orders',
+        'write_third_party_fulfillment_orders',
+        'write_assigned_fulfillment_orders',
+    ],
+    cancelOrder: ['write_orders'],
+    /* Depende del dueño al que apunte `ownerId`. Ver la cabecera. */
+    setMetafield: [],
+    createProduct: ['write_products'],
+};
+/**
+ * Which of an operation's scopes the credential does NOT have.
+ *
+ * Empty means "nothing to say" — and it says that in three different
+ * situations, all of which have to fail OPEN:
+ *
+ *   1. The operation declares no scope (the resource-dependent ones).
+ *   2. The credential has a scope string and it covers one of the alternatives.
+ *   3. **The credential has no scope string at all.** Shopify returns the
+ *      granted scopes on the token exchange, but a credential stored before
+ *      that was read, or one whose metadata was pruned, has an empty string —
+ *      and refusing to run a node because we cannot see its permissions would
+ *      break working flows to prevent a maybe. Shopify is the authority here;
+ *      this check only saves the round trip when it can prove the answer.
+ *
+ * @param concedidos what Shopify granted, as it sends it: a comma-separated
+ *   string, or the already-split list.
+ */
+function scopesQueFaltanEnShopify(concedidos, requeridos) {
+    if (requeridos.length === 0)
+        return [];
+    const lista = (typeof concedidos === 'string'
+        ? concedidos.split(',')
+        : Array.isArray(concedidos)
+            ? concedidos
+            : [])
+        .map((s) => String(s).trim())
+        .filter(Boolean);
+    // Fail open: sin scopes a la vista no se puede probar que falte ninguno.
+    if (lista.length === 0)
+        return [];
+    const tiene = new Set(lista);
+    const cubierto = (scope) => tiene.has(scope) ||
+        // `write_x` incluye `read_x`, y ésa es la única implicación que existe.
+        (scope.startsWith('read_') && tiene.has(`write_${scope.slice(5)}`));
+    // «Cualquiera de» — con una basta, y entonces no falta nada.
+    if (requeridos.some(cubierto))
+        return [];
+    return [...requeridos];
+}

package/dist/types.d.ts

@@ -38,7 +38,20 @@ export interface NodeUIConfig {
         hasBranches?: boolean;
         isTerminal?: boolean;
         hasLoopBack?: boolean;
-        connectModal?: 'branch' | 'rule' | 'output-group';
+        /**
+         * Aquí había también un `'rule'`, sólo para el router, y con él vivía en
+         * el lienzo un camino de conexión a medida: su propio modal, su propio
+         * `handleRuleSelect` y su propia puerta en `onConnect`. Dos mecanismos
+         * para lo mismo, y así es como uno se arregla y el otro no: el modal del
+         * router salía al ARRASTRAR y nunca al pulsar el `+`, porque ese segundo
+         * camino pasa por `outputGroups` — que el router no declaraba.
+         *
+         * El router ramifica igual que el conditional, el split y el clasificador,
+         * y su destino vive en el mismo sitio que el de ellos (`port: rule:<id>`),
+         * así que usa la misma maquinaria. Se quita del tipo para que no pueda
+         * volver a declararse sin que el compilador lo diga.
+         */
+        connectModal?: 'branch' | 'output-group';
         routerTargetLabel?: string;
         /**
          * Generic named output groups — used by connectModal: 'output-group'.
@@ -54,6 +67,20 @@ export interface NodeUIConfig {
             nameField?: string;
             /** Field within each group for summary/description (e.g. 'field', 'filterMode') */
             summaryField?: string;
+            /**
+             * Varios campos del grupo, unidos por espacios, cuando el resumen que
+             * de verdad identifica al grupo no cabe en uno solo.
+             *
+             * Existe por las reglas del router: su condición son TRES campos
+             * (`field`, `operator`, `value`) y el modal a medida que se retiró las
+             * pintaba juntas — «status eq active». Con un único `summaryField` una
+             * regla sin `label` quedaba en «rule 1» y «status», que no dice a qué
+             * se está conectando uno.
+             *
+             * Los campos vacíos se saltan, para que una regla con operador
+             * `exists` no salga con un espacio colgando al final.
+             */
+            summaryFields?: string[];
             /** Label shown in the modal (e.g. 'output', 'branch') */
             label: string;
             /** Entity field for the fallback/else path (e.g. 'elseOutputNodes') */
@@ -80,6 +107,29 @@ export interface NodeUIConfig {
                 field: string;
                 value: unknown;
             };
+            /**
+             * Qué es el puerto `main` de este nodo MIENTRAS su contenedor está
+             * vacío. Sin esto, conectar a un nodo que ramifica y todavía no tiene
+             * ninguna salida escribía una arista en `main` **en silencio**, y el
+             * usuario no tenía forma de saber qué había pasado con ella.
+             *
+             * No hay una respuesta única, y por eso es un dato y no una regla.
+             * Medido en `api/src/common/pipeline-run.service.ts`:
+             *
+             *   'passthrough'       — router sin reglas: `rules.length === 0
+             *                         ? refsForPort(entity, MAIN_PORT) : []`. La
+             *                         arista SÍ dispara... hasta que se cree la
+             *                         primera regla, y entonces deja de hacerlo
+             *                         sin avisar.
+             *   'never-dispatched'  — split: no tiene salida `main`, y el propio
+             *                         despachador registra un warning por cada
+             *                         arista que se quedó en ese puerto.
+             *
+             * Se declara sólo donde se ha medido. Sin declarar, el lienzo se
+             * comporta como siempre: conecta por el camino universal y no dice
+             * nada, que es lo que hacía antes de existir este campo.
+             */
+            emptyContainerMain?: 'passthrough' | 'never-dispatched';
         };
         /**
          * Maps output fields to alternate payload fields on the source entity.

package/dist/ui.js

@@ -54,12 +54,30 @@ exports.NODE_UI = {
     fileTransform: { fromNodes: true, toNodes: true },
     limit: { fromNodes: true, toNodes: true, special: { loopBackAllowed: true } },
     // ── Flow control nodes ──
-    split: { fromNodes: true, toNodes: true, outputHandles: ['right'], special: { connectModal: 'output-group', outputGroups: { field: 'outputs', nameField: 'name', summaryField: 'field', label: 'output' } } },
+    // `emptyContainerMain: 'never-dispatched'` dice lo que el despachador ya
+    // registra como warning: un split NO tiene salida `main`, así que una arista
+    // que se quede ahí —la que se guardaba al conectar un split sin salidas— no
+    // se despacha nunca. Ver `pipeline-run.service.ts`, el bloque `nodeType ===
+    // 'split'`. El lienzo lo usa para avisar en vez de callarse.
+    split: { fromNodes: true, toNodes: true, outputHandles: ['right'], special: { connectModal: 'output-group', outputGroups: { field: 'outputs', nameField: 'name', summaryField: 'field', label: 'output', emptyContainerMain: 'never-dispatched' } } },
     merge: { fromNodes: true, toNodes: true, inputHandles: ['left', 'top'] },
     approval: { fromNodes: true, toNodes: true, outputHandles: ['right'], special: { connectModal: 'output-group', outputGroups: { fixedGroups: [{ name: 'Approve', field: 'outputNodes' }, { name: 'Reject', field: 'rejectionOutputNodes' }], label: 'action' } } },
     loop: { fromNodes: true, toNodes: true, inputHandles: ['left'], outputHandles: ['right'], dotHandles: { input: ['left-in'], output: ['right-out-loop', 'right-in-loopback', 'right-out-done'] }, special: { hasLoopBack: true, alternatePayloads: { doneOutputNodes: 'lastDonePayload' } } },
     // ── Routing nodes ──
-    router: { fromNodes: true, toNodes: true, outputHandles: ['right'], dotHandles: { output: ['right-out'] }, special: { connectModal: 'rule' } },
+    // El router ramifica igual que el conditional, el split y el clasificador:
+    // sus salidas son un contenedor (`rules[]`) y el destino de cada una vive en
+    // la arista, en `port: rule:<id>`. Lo único que le faltaba era DECIRLO aquí.
+    //
+    // Mientras no lo decía, tenía en el lienzo un camino propio —`connectModal:
+    // 'rule'`, con su modal, su `handleRuleSelect` y su puerta en `onConnect`— y
+    // eso dejaba el `+` fuera: ese camino no pasa por `onConnect`, pregunta por
+    // `outputGroups`, y el router no tenía. Arrastrando salía el modal; pulsando
+    // el `+` la arista se guardaba en `main` sin preguntar nada.
+    //
+    // `nameField: 'label'` porque el `label` de una regla es opcional; cuando
+    // falta, el modal numera («rule 1») y el `summaryFields` de al lado pone la
+    // condición, que es lo que de verdad la identifica.
+    router: { fromNodes: true, toNodes: true, outputHandles: ['right'], dotHandles: { output: ['right-out'] }, special: { connectModal: 'output-group', outputGroups: { field: 'rules', nameField: 'label', summaryFields: ['field', 'operator', 'value'], label: 'rule', emptyContainerMain: 'passthrough' } } },
     // ── Action nodes ──
     emailAction: { fromNodes: true, toNodes: true, inputHandles: ['left', 'top'], outputHandles: ['right'], dotHandles: { input: ['left-in', 'top-in'], output: ['right-out'] }, special: { loopBackAllowed: true, routerTargetLabel: 'email' } },
     gmailAction: { fromNodes: true, toNodes: true, inputHandles: ['left', 'top'], outputHandles: ['right'], dotHandles: { input: ['left-in', 'top-in'], output: ['right-out'] }, special: { loopBackAllowed: true, routerTargetLabel: 'gmail' } },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hostwebhook/node-types",
-  "version": "1.73.0",
+  "version": "1.75.0",
   "description": "Shared node type definitions, connection rules, and dispatch config for HostWebhook",
   "main": "dist/index.js",
   "module": "dist/esm/index.js",