node-red-contrib-ax25 1.0.0

package/nodes/raw-out.html

@@ -0,0 +1,76 @@
+<script type="text/javascript">
+RED.nodes.registerType("raw-out", {
+  category: "agwpe",
+  color: "#d4edda",
+  defaults: {
+    client: { value: "", type: "agwpe-client", required: true },
+    name: { value: "" },
+    agwpePort: { value: 0 }
+  },
+  inputs: 1,
+  outputs: 1,
+  icon: "font-awesome/fa-upload",
+  oneditprepare: function () {
+    const value = this.agwpePort !== undefined ? this.agwpePort : this.flag;
+    const parsed = Number(value);
+    const normalized = Number.isInteger(parsed) && parsed >= 0 && parsed <= 255 ? parsed : 0;
+    $("#node-input-agwpePort").val(normalized);
+  },
+  oneditsave: function () {
+    const parsed = Number($("#node-input-agwpePort").val());
+    this.agwpePort = Number.isInteger(parsed) && parsed >= 0 && parsed <= 255 ? parsed : 0;
+  },
+  label: function () {
+    return this.name || "raw-out";
+  }
+});
+</script>
+
+<script type="text/html" data-template-name="raw-out">
+  <div class="form-row">
+    <label for="node-input-client"><i class="fa fa-server"></i> Client</label>
+    <input type="text" id="node-input-client" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-agwpePort"><i class="fa fa-flag"></i> AGWPE Port</label>
+    <input type="number" id="node-input-agwpePort" min="0" max="255" step="1" />
+  </div>
+</script>
+
+<script type="text/html" data-help-name="raw-out">
+  <p>Sends a raw AX.25 frame when raw mode is enabled on the AGWPE client node.</p>
+
+  <h3>Input</h3>
+  <dl class="message-properties">
+    <dt>payload <span class="property-type">Buffer | array | Uint8Array | string | object</span></dt>
+    <dd>The raw AX.25 frame bytes to transmit. Accepted formats:
+      <ul>
+        <li><b>Buffer</b> — used as-is.</li>
+        <li><b>byte array</b> or <b>Uint8Array</b> — converted to a Buffer.</li>
+        <li><b>hex string</b> — pairs of hex digits, optionally separated by spaces or commas
+        (e.g. <code>"82 a0 a8"</code> or <code>"82a0a8"</code>). <code>0x</code> prefixes are stripped.</li>
+        <li><b>encode envelope</b> — if <code>msg.payload</code> is an output message from the
+        <b>encode</b> node, its nested <code>payload</code> Buffer is used automatically.</li>
+      </ul>
+    </dd>
+    <dt class="optional">agwpePort <span class="property-type">number</span></dt>
+    <dd>AGWPE port byte (0–255) identifying the TNC port to transmit on. Overrides the editor
+    value. Defaults to <code>0</code> if neither the message nor the editor provides a value.</dd>
+  </dl>
+
+  <h3>Output</h3>
+  <dl class="message-properties">
+    <dt>status <span class="property-type">string</span></dt>
+    <dd><code>"ok"</code> on success; <code>"error"</code> if the send fails. Check this field first.</dd>
+    <dt>event <span class="property-type">string</span></dt>
+    <dd>When <code>status</code> is <code>"ok"</code>: always <code>"raw-sent"</code>.</dd>
+    <dt class="optional">errorCode <span class="property-type">string</span></dt>
+    <dd>When <code>status</code> is <code>"error"</code>: <code>CLIENT_NOT_FOUND</code>, <code>RAW_MODE_DISABLED</code>, or <code>RAW_FRAME_INVALID</code>.</dd>
+    <dt class="optional">errorText <span class="property-type">string</span></dt>
+    <dd>When <code>status</code> is <code>"error"</code>: human-readable description of the error.</dd>
+  </dl>
+</script>

package/nodes/raw-out.js

@@ -0,0 +1,144 @@
+"use strict";
+
+const { okEnvelope, errorEnvelope } = require("../lib/message-utils");
+
+function toByte(value) {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 0 || n > 255) {
+    throw new Error("RAW_FRAME_INVALID_BYTE");
+  }
+  return n;
+}
+
+function isBufferJsonObject(value) {
+  return (
+    value &&
+    typeof value === "object" &&
+    value.type === "Buffer" &&
+    Array.isArray(value.data)
+  );
+}
+
+function parseHexString(input) {
+  const cleaned = String(input || "")
+    .trim()
+    .replace(/0x/gi, "")
+    .replace(/[\s,]+/g, "");
+
+  if (!cleaned) {
+    throw new Error("RAW_FRAME_EMPTY");
+  }
+  if (!/^[0-9a-fA-F]+$/.test(cleaned) || cleaned.length % 2 !== 0) {
+    throw new Error("RAW_FRAME_INVALID_HEX");
+  }
+
+  return Buffer.from(cleaned, "hex");
+}
+
+function coercePayloadToBuffer(payload) {
+  if (Buffer.isBuffer(payload)) {
+    return payload;
+  }
+
+  if (isBufferJsonObject(payload)) {
+    return Buffer.from(payload.data.map(toByte));
+  }
+
+  if (payload instanceof Uint8Array) {
+    return Buffer.from(payload);
+  }
+
+  if (Array.isArray(payload)) {
+    return Buffer.from(payload.map(toByte));
+  }
+
+  if (typeof payload === "string") {
+    return parseHexString(payload);
+  }
+
+  throw new Error("RAW_FRAME_INVALID");
+}
+
+function getRawFrameInput(msg) {
+  const direct = msg ? msg.payload : undefined;
+  if (
+    direct &&
+    typeof direct === "object" &&
+    !Buffer.isBuffer(direct) &&
+    !Array.isArray(direct) &&
+    !(direct instanceof Uint8Array) &&
+    !isBufferJsonObject(direct) &&
+    Object.prototype.hasOwnProperty.call(direct, "payload")
+  ) {
+    // Accept nested envelopes (for example: msg.payload = <encode output message>)
+    return direct.payload;
+  }
+  return direct;
+}
+
+function resolveAgwpePort(msg, node) {
+  const msgPort = msg ? msg.agwpePort : undefined;
+  const msgFlag = msg ? msg.flag : undefined; // backward-compatible alias
+  const configuredPort = node.agwpePort;
+  const selected = msgPort !== undefined
+    ? msgPort
+    : (msgFlag !== undefined ? msgFlag : configuredPort);
+  return toByte(selected === undefined || selected === null || selected === "" ? 0 : selected);
+}
+
+module.exports = function (RED) {
+  function RawOutNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    node.agwpePort = config.agwpePort !== undefined ? config.agwpePort : config.flag;
+
+    const cfg = RED.nodes.getNode(config.client);
+    const context = cfg ? cfg.instance : null;
+
+    node.on("input", function (msg, send, done) {
+      const localSend = send || function (m) {
+        node.send(m);
+      };
+      const localDone = done || function () {};
+
+      if (!context) {
+        localSend(errorEnvelope("CLIENT_NOT_FOUND", "AGWPE Client instance not found"));
+        localDone();
+        return;
+      }
+
+      if (!context.rawEnabled) {
+        localSend(errorEnvelope("RAW_MODE_DISABLED", "Raw mode is disabled"));
+        localDone();
+        return;
+      }
+
+      let rawPayload;
+      let agwpePort;
+      try {
+        rawPayload = coercePayloadToBuffer(getRawFrameInput(msg));
+        agwpePort = resolveAgwpePort(msg, node);
+      } catch (error) {
+        localSend(
+          errorEnvelope(
+            "RAW_FRAME_INVALID",
+            "Raw frame payload/agwpePort is invalid; payload must be Buffer, byte array, Uint8Array, hex string, or encode envelope"
+          )
+        );
+        localDone();
+        return;
+      }
+
+      context.bus.emit("raw-data", {
+        instanceId: context.instanceId,
+        payload: rawPayload,
+        agwpePort,
+        direction: "tx"
+      });
+      localSend(okEnvelope({ instanceId: context.instanceId, event: "raw-sent" }));
+      localDone();
+    });
+  }
+
+  RED.nodes.registerType("raw-out", RawOutNode);
+};

package/nodes/send.html

@@ -0,0 +1,91 @@
+<script type="text/javascript">
+RED.nodes.registerType("send", {
+  category: "agwpe",
+  color: "#d4edda",
+  defaults: {
+    name: { value: "" },
+    timeout: { value: 0 },
+    waitFor: { value: "" }
+  },
+  inputs: 1,
+  outputs: 2,
+  outputLabels: ["events", "data"],
+  icon: "font-awesome/fa-paper-plane",
+  label: function () {
+    return this.name || "send";
+  }
+});
+</script>
+
+<script type="text/html" data-template-name="send">
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-timeout"><i class="fa fa-clock-o"></i> Timeout (ms)</label>
+    <input type="number" id="node-input-timeout" placeholder="0 = disabled (overridden by msg.timeout)" min="0" style="width:auto" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-waitFor"><i class="fa fa-search"></i> Wait For</label>
+    <input type="text" id="node-input-waitFor" placeholder="regex e.g. >$" />
+  </div>
+</script>
+
+<script type="text/html" data-help-name="send">
+  <p>Sends data over an AX.25 connected session, and receives inbound data in response.</p>
+  <p>Emits session lifecycle events on output 1 and inbound data from the remote station on output 2.</p>
+
+  <h3>Input</h3>
+  <dl class="message-properties">
+    <dt>sessionId <span class="property-type">string</span></dt>
+    <dd>Session to act on.</dd>
+    <dt class="optional">payload <span class="property-type">string | Buffer</span></dt>
+    <dd>Data to send. Required for <code>send</code>. In line mode a trailing <code>\r</code> is appended automatically.</dd>
+    <dt class="optional">waitFor <span class="property-type">string</span></dt>
+    <dd>Regex pattern (overrides node config). After the send, inbound lines are buffered until one matches, then emitted on output 2 as <code>msg.payload</code> (array) with the matching line in <code>msg.match</code>.</dd>
+    <dt class="optional">timeout <span class="property-type">number</span></dt>
+    <dd>Inactivity timeout in milliseconds. Overrides node config. Resets the timer for the session. If no data arrives within this window, a <code>timeout</code> event is emitted on output 1 of <em>this</em> node. Set to <code>0</code> to disable.</dd>
+  </dl>
+
+  <h3>Outputs</h3>
+  <ol class="node-ports">
+    <li>Events
+      <dl class="message-properties">
+        <dt>status <span class="property-type">string</span></dt>
+        <dd><code>"ok"</code> on success; <code>"error"</code> on error.</dd>
+        <dt>event <span class="property-type">string</span></dt>
+        <dd>When <code>status</code> is <code>"ok"</code>: <code>sent</code>.</dd>
+        <dt>sessionId <span class="property-type">string</span></dt>
+        <dd>Identifies the session.</dd>
+        <dt class="optional">messageId <span class="property-type">string</span></dt>
+        <dd>Unique ID for the sent message. Present on <code>sent</code> events.</dd>
+        <dt class="optional">chunkCount <span class="property-type">number</span></dt>
+        <dd>Number of AGWPE frames the payload was split into. Present on <code>sent</code> events.</dd>
+        <dt class="optional">errorCode <span class="property-type">string</span></dt>
+        <dd>When <code>status</code> is <code>"error"</code>: <code>SESSION_NOT_FOUND</code>, <code>SESSION_NOT_CONNECTED</code>, <code>PAYLOAD_INVALID</code>, or <code>TIMEOUT</code> (inactivity timeout; <code>event</code> is also set to <code>"timeout"</code>).</dd>
+        <dt class="optional">errorText <span class="property-type">string</span></dt>
+        <dd>When <code>status</code> is <code>"error"</code>: human-readable description of the error.</dd>
+      </dl>
+    </li>
+    <li>Data
+      <dl class="message-properties">
+        <dt>event <span class="property-type">string</span></dt>
+        <dd>Always <code>"data"</code>.</dd>
+        <dt>payload <span class="property-type">string | Buffer | array</span></dt>
+        <dd>In line mode without <code>waitFor</code>: one string per line. With <code>waitFor</code>: array of lines buffered before the match. In binary mode: a Buffer.</dd>
+        <dt class="optional">match <span class="property-type">string</span></dt>
+        <dd>The line that triggered the <code>waitFor</code> pattern. Only present when <code>waitFor</code> is set and matched.</dd>
+        <dt>sessionId <span class="property-type">string</span></dt>
+        <dd>Identifies the session this data belongs to.</dd>
+      </dl>
+    </li>
+  </ol>
+
+  <h3>Details</h3>
+  <p>When a <code>send</code> command is processed, this node re-claims the data output for the
+  session. Inbound data received after the send is routed through this node's output 2
+  until another Send node takes over or the session closes.</p>
+  <p><b>Timeout</b> and <b>Wait For</b> can be set on the node and overridden per-message via <code>msg.timeout</code> and <code>msg.waitFor</code>.
+  Leave <b>Wait For</b> blank to emit one message per line.</p>
+</script>

package/nodes/send.js

@@ -0,0 +1,373 @@
+"use strict";
+
+const { splitPayload } = require("../lib/frame-segmentation");
+const { okEnvelope, errorEnvelope, makeMessageId } = require("../lib/message-utils");
+const store = require("../lib/runtime-store");
+
+// Maximum number of unacknowledged I-frames the TNC may hold before we pause.
+// Matches the standard AX.25 modulo-8 window.
+const MAX_OUTSTANDING = 7;
+
+// How long to wait (ms) before re-querying the TNC when its buffer is full.
+const Y_RETRY_DELAY_MS = 200;
+
+// How long to wait (ms) for a Y response before giving up and sending anyway.
+const Y_RESPONSE_TIMEOUT_MS = 2000;
+
+function parseWaitFor(pattern) {
+  if (!pattern || typeof pattern !== "string" || pattern.trim() === "") return null;
+  try {
+    return new RegExp(pattern);
+  } catch (e) {
+    return null;
+  }
+}
+
+function normalizeSend(node, send) {
+  return send || function (msg) {
+    node.send(msg);
+  };
+}
+
+// Mirror of the helper in connect.js; shared logic for inbound frame delivery.
+function ensureConnBuffers(context) {
+  if (!context.outputClaims) context.outputClaims = new Map();
+  if (!context.lineBuffers) context.lineBuffers = new Map();
+  if (!context.waitForBuffers) context.waitForBuffers = new Map();
+}
+
+function deliverFrame(context, node, sessionId, frame) {
+  const session = context.registry.get(context.instanceId, sessionId);
+  const mode = (session && session.mode) || "binary";
+
+  if (mode === "binary") {
+    node.send([null, okEnvelope({
+      instanceId: context.instanceId,
+      sessionId,
+      event: "data",
+      payload: frame.payload,
+      source: frame.source,
+      destination: frame.destination,
+      via: frame.via || []
+    })]);
+    return;
+  }
+
+  const prev = context.lineBuffers.get(sessionId) || "";
+  const combined = prev + frame.payload.toString();
+  const lines = combined.split(/\r\n|\r/);
+  context.lineBuffers.set(sessionId, lines.pop());
+
+  const claim = context.outputClaims.get(sessionId);
+  const waitFor = claim ? claim.waitFor : null;
+
+  if (!waitFor) {
+    lines.forEach(function (line) {
+      node.send([null, okEnvelope({
+        instanceId: context.instanceId,
+        sessionId,
+        event: "data",
+        payload: line,
+        source: frame.source,
+        destination: frame.destination,
+        via: frame.via || []
+      })]);
+    });
+  } else {
+    const buf = context.waitForBuffers.get(sessionId) || [];
+    buf.push.apply(buf, lines);
+
+    let matchIdx = -1;
+    for (let i = 0; i < buf.length; i++) {
+      if (waitFor.test(buf[i])) {
+        matchIdx = i;
+        break;
+      }
+    }
+
+    if (matchIdx >= 0) {
+      const outLines = buf.splice(0, matchIdx + 1);
+      const match = outLines.pop();
+      context.waitForBuffers.set(sessionId, buf);
+      const timerEntry = context.sessionTimers && context.sessionTimers.get(sessionId);
+      if (timerEntry) { clearTimeout(timerEntry.t); context.sessionTimers.delete(sessionId); }
+      node.send([null, okEnvelope({
+        instanceId: context.instanceId,
+        sessionId,
+        event: "data",
+        payload: outLines,
+        match,
+        source: frame.source,
+        destination: frame.destination,
+        via: frame.via || []
+      })]);
+    } else {
+      // Also check the current line fragment (e.g. a BBS prompt with no trailing CR/LF).
+      const fragment = context.lineBuffers.get(sessionId) || "";
+      if (fragment && waitFor.test(fragment)) {
+        context.lineBuffers.set(sessionId, "");
+        context.waitForBuffers.delete(sessionId);
+        const timerEntry = context.sessionTimers && context.sessionTimers.get(sessionId);
+        if (timerEntry) { clearTimeout(timerEntry.t); context.sessionTimers.delete(sessionId); }
+        node.send([null, okEnvelope({
+          instanceId: context.instanceId,
+          sessionId,
+          event: "data",
+          payload: buf,
+          match: fragment,
+          source: frame.source,
+          destination: frame.destination,
+          via: frame.via || []
+        })]);
+      } else {
+        context.waitForBuffers.set(sessionId, buf);
+      }
+    }
+  }
+}
+
+/**
+ * Emit a single data chunk onto the instance bus after confirming the TNC has
+ * room for it.  Sends a 'y' query, waits for the 'Y' response and, if the TNC
+ * reports fewer than MAX_OUTSTANDING pending frames, emits the 'conn-data'
+ * event.  If the TNC is full the query is retried after Y_RETRY_DELAY_MS.
+ * If no 'Y' response arrives within Y_RESPONSE_TIMEOUT_MS the chunk is sent
+ * unconditionally so a non-responsive TNC does not stall the node forever.
+ *
+ * @param {object}   ctx         - Instance context from runtime-store.
+ * @param {string}   source      - Our callsign.
+ * @param {string}   destination - Remote callsign.
+ * @param {object}   chunkEvent  - The full conn-data event payload to emit.
+ * @param {Function} callback    - Called with no arguments when the chunk has
+ *                                 been emitted (or the timeout fires).
+ */
+function sendChunkWithFlowControl(ctx, source, destination, chunkEvent, callback) {
+  const normSource = (source || "").toUpperCase();
+  const normDest   = (destination || "").toUpperCase();
+
+  function attempt() {
+    let settled = false;
+    let retryTimer = null;
+
+    const responseTimeout = setTimeout(function () {
+      if (settled) return;
+      settled = true;
+      ctx.bus.off("conn-y-response", onYResponse);
+      // No response from TNC — send without flow control.
+      ctx.bus.emit("conn-data", chunkEvent);
+      callback();
+    }, Y_RESPONSE_TIMEOUT_MS);
+
+    function onYResponse(response) {
+      const rSrc  = (response.source      || "").toUpperCase();
+      const rDest = (response.destination || "").toUpperCase();
+      if (rSrc !== normSource || rDest !== normDest) return;
+
+      if (settled) return;
+      settled = true;
+      ctx.bus.off("conn-y-response", onYResponse);
+      clearTimeout(responseTimeout);
+
+      if (response.outstanding >= MAX_OUTSTANDING) {
+        // TNC buffer full — back off and retry.
+        retryTimer = setTimeout(attempt, Y_RETRY_DELAY_MS);
+        return;
+      }
+
+      ctx.bus.emit("conn-data", chunkEvent);
+      callback();
+    }
+
+    ctx.bus.on("conn-y-response", onYResponse);
+    ctx.bus.emit("conn-y-query", {
+      instanceId: ctx.instanceId,
+      source,
+      destination,
+      direction: "tx"
+    });
+  }
+
+  attempt();
+}
+
+/**
+ * Send all chunks for one payload item sequentially through Y-based flow
+ * control.  Calls callback(null) when all chunks have been queued on the bus.
+ */
+function sendChunksWithFlowControl(ctx, source, destination, sessionId, messageId, chunks, callback) {
+  let index = 0;
+
+  function nextChunk() {
+    if (index >= chunks.length) {
+      callback(null);
+      return;
+    }
+
+    const chunkIndex = index;
+    const chunk      = chunks[index++];
+    const chunkEvent = {
+      instanceId: ctx.instanceId,
+      sessionId,
+      messageId,
+      chunkIndex,
+      chunkCount: chunks.length,
+      direction:  "tx",
+      payload:    chunk,
+      source,
+      destination
+    };
+
+    sendChunkWithFlowControl(ctx, source, destination, chunkEvent, nextChunk);
+  }
+
+  nextChunk();
+}
+
+module.exports = function (RED) {
+  function SendNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    // config.client is no longer required for routing. The agwpe-client instance is
+    // derived at runtime from the sessionId via the global session index, so a Send
+    // node works automatically with whatever agwpe-client the Connect node used.
+    node.status({});
+
+    // Inbound data handler: fires for all instances via the global bus.
+    // Only processes frames for sessions where this node holds the output claim.
+    const onData = function (frame) {
+      if (frame.direction === "tx") return;
+      if (frame.event === "connect" || frame.event === "disconnect") return;
+
+      const sessionId = frame.sessionId;
+      // frame.instanceId is set by all real bus emissions; fall back to the session
+      // index for test events that omit it.
+      const iid = frame.instanceId || store.instanceIdForSession(sessionId);
+      if (!iid) return;
+
+      const context = store.getInstance(iid);
+      if (!context) return;
+
+      ensureConnBuffers(context);
+      const claim = context.outputClaims.get(sessionId);
+      if (!claim || claim.node !== node) return;
+
+      deliverFrame(context, node, sessionId, frame);
+    };
+
+    store.globalBus.on("conn-data", onData);
+
+    node.on("input", function (msg, send, done) {
+      const localSend = normalizeSend(node, send);
+      const localDone = done || function () {};
+
+      const iid = store.instanceIdForSession(msg.sessionId);
+      const ctx = iid ? store.getInstance(iid) : null;
+      const session = ctx ? ctx.registry.get(ctx.instanceId, msg.sessionId) : null;
+      if (!session) {
+        localSend([errorEnvelope("SESSION_NOT_FOUND", "Session not found", { sessionId: msg.sessionId }), null]);
+        localDone();
+        return;
+      }
+      if (session.state !== "connected") {
+        localSend([errorEnvelope("SESSION_NOT_CONNECTED", "Session is not connected", { sessionId: msg.sessionId }), null]);
+        localDone();
+        return;
+      }
+      // Allow array payloads: each item is sent as a separate D frame.
+      const payloadItems = Array.isArray(msg.payload) ? msg.payload : [msg.payload];
+      for (let i = 0; i < payloadItems.length; i++) {
+        if (typeof payloadItems[i] !== "string" && !Buffer.isBuffer(payloadItems[i])) {
+          localSend([errorEnvelope("PAYLOAD_INVALID", "payload items must be string or Buffer", { sessionId: msg.sessionId }), null]);
+          localDone();
+          return;
+        }
+      }
+
+      ensureConnBuffers(ctx);
+      // Claim output for this session; flush any pending waitFor buffer if claim is changing.
+      const currentClaim = ctx.outputClaims.get(msg.sessionId);
+      if (currentClaim && currentClaim.node !== node) {
+        const pendingBuf = ctx.waitForBuffers.get(msg.sessionId);
+        if (pendingBuf && pendingBuf.length > 0) {
+          currentClaim.node.send([null, okEnvelope({
+            instanceId: ctx.instanceId,
+            sessionId: msg.sessionId,
+            event: "data",
+            payload: pendingBuf
+          })]);
+          ctx.waitForBuffers.delete(msg.sessionId);
+        }
+      }
+      ctx.outputClaims.set(msg.sessionId, { node, waitFor: parseWaitFor(msg.waitFor || config.waitFor) });
+
+      const resolvedTimeout = (typeof msg.timeout === "number" && msg.timeout > 0) ? msg.timeout
+        : (typeof config.timeout === "number" && config.timeout > 0) ? config.timeout : null;
+      if (resolvedTimeout) {
+        ctx.registry.update(ctx.instanceId, msg.sessionId, { timeoutMs: resolvedTimeout });
+        ctx.bus.emit("conn-timeout-set", { sessionId: msg.sessionId, timeoutMs: resolvedTimeout });
+      }
+
+      const sessionMode = session.mode || "binary";
+      const source      = session.source || session.sourceCallsign;
+      const destination = session.destination || session.destinationCallsign;
+
+      // Build all (item, chunks) pairs up front so we know totalChunkCount before
+      // any async work begins, and can report the correct value in the 'sent' event.
+      const itemJobs = payloadItems.map(function (item) {
+        let sendItem = item;
+        if (sessionMode === "line") {
+          const itemStr = Buffer.isBuffer(sendItem) ? sendItem.toString() : String(sendItem);
+          sendItem = itemStr + "\r";
+        }
+        return { messageId: makeMessageId("conn"), chunks: splitPayload(sendItem, 256) };
+      });
+
+      const totalChunkCount = itemJobs.reduce(function (acc, j) { return acc + j.chunks.length; }, 0);
+      const lastMessageId   = itemJobs.length > 0 ? itemJobs[itemJobs.length - 1].messageId : undefined;
+
+      // Send payload items sequentially, each with Y-based per-chunk flow control.
+      let jobIndex = 0;
+      function nextJob() {
+        if (jobIndex >= itemJobs.length) {
+          localSend([
+            okEnvelope({
+              instanceId: ctx.instanceId,
+              event: "sent",
+              sessionId: msg.sessionId,
+              messageId: lastMessageId,
+              chunkCount: totalChunkCount
+            }),
+            null
+          ]);
+          localDone();
+          return;
+        }
+
+        const job = itemJobs[jobIndex++];
+        sendChunksWithFlowControl(ctx, source, destination, msg.sessionId, job.messageId, job.chunks, function () {
+          nextJob();
+        });
+      }
+
+      nextJob();
+    });
+
+    node.on("close", function (removed, done) {
+      store.globalBus.off("conn-data", onData);
+      // Release output claims held by this node across all instances.
+      store.getAllInstances().forEach(function (context) {
+        if (context.outputClaims) {
+          context.outputClaims.forEach(function (claim, sessionId) {
+            if (claim.node === node) {
+              context.outputClaims.delete(sessionId);
+            }
+          });
+        }
+      });
+      done();
+    });
+  }
+
+  RED.nodes.registerType("send", SendNode);
+};