@revenexx/integrations-node-sdk 1.13.0 → 1.15.0

package/dist/{chunk-XO73F62E.js → chunk-CA6JVLLF.js}

@@ -92,6 +92,53 @@ function parsePackageMeta(raw) {
     icon: icon !== "" ? icon : void 0
   };
 }
+var SLUG_PATTERN = "^[a-z][a-z0-9-]{0,62}$";
+var NAMESPACED_SLUG_PATTERN = "^[a-z][a-z0-9-]{0,62}:[a-z][a-z0-9-]{0,62}$";
+var SEMVER_PATTERN = "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?$";
+var CONFIG_KEY_PATTERN = "^[a-zA-Z][a-zA-Z0-9-]*$";
+var PATTERN_HINT = {
+  [SLUG_PATTERN]: 'lowercase kebab-case, such as "not-found"',
+  [NAMESPACED_SLUG_PATTERN]: '"<namespace>:<name>" in lowercase kebab-case, such as "core:http-request"',
+  [SEMVER_PATTERN]: 'a semantic version, such as "1.0.0"',
+  [CONFIG_KEY_PATTERN]: 'a letter, then letters, digits or "-", such as "postalCode"'
+};
+function nodeManifestProblems(nodes) {
+  const problems = [];
+  for (const [index, node] of nodes.entries()) {
+    const who = `node ${index + 1} (${typeof node.slug === "string" ? node.slug : "no slug"})`;
+    const check = (path, value, pattern) => {
+      if (value === void 0 || typeof value === "string" && new RegExp(pattern).test(value)) return;
+      problems.push(
+        `${who}: ${path} ${JSON.stringify(value)} is refused by the registry \u2014 it must match ${pattern} (${PATTERN_HINT[pattern]}).`
+      );
+    };
+    check("slug", node.slug, NAMESPACED_SLUG_PATTERN);
+    check("version", node.version, SEMVER_PATTERN);
+    for (const [i, port] of (node.outputs ?? []).entries()) {
+      check(`outputs[${i}].name`, port.name, SLUG_PATTERN);
+      check(`outputs[${i}].sourceFromConfig`, port.sourceFromConfig, SLUG_PATTERN);
+      check(`outputs[${i}].fallback.name`, port.fallback?.name, SLUG_PATTERN);
+    }
+    const checkField = (field, at) => {
+      check(`${at}.key`, field.key, CONFIG_KEY_PATTERN);
+      for (const [j, key] of (field.dependsOn ?? []).entries()) check(`${at}.dependsOn[${j}]`, key, CONFIG_KEY_PATTERN);
+      check(`${at}.showIf.key`, field.showIf?.key, CONFIG_KEY_PATTERN);
+      const types = field.credentialType;
+      if (Array.isArray(types)) {
+        for (const [j, type] of types.entries()) check(`${at}.credentialType[${j}]`, type, NAMESPACED_SLUG_PATTERN);
+      } else {
+        check(`${at}.credentialType`, types, NAMESPACED_SLUG_PATTERN);
+      }
+      walk(field.properties, `${at}.properties`);
+      if (field.items) checkField(field.items, `${at}.items`);
+    };
+    const walk = (fields, path) => {
+      for (const [i, field] of (fields ?? []).entries()) checkField(field, `${path}[${i}]`);
+    };
+    walk(node.config, "config");
+  }
+  return problems;
+}
 function buildManifest(nodes, credentials = [], templates = []) {
   const manifest = {
     manifestVersion: MANIFEST_VERSION,
@@ -118,5 +165,10 @@ export {
   MANIFEST_VERSION,
   packageIconProblem,
   parsePackageMeta,
+  SLUG_PATTERN,
+  NAMESPACED_SLUG_PATTERN,
+  SEMVER_PATTERN,
+  CONFIG_KEY_PATTERN,
+  nodeManifestProblems,
   buildManifest
 };

package/dist/cli.cjs

@@ -147,6 +147,53 @@ function parsePackageMeta(raw) {
     icon: icon !== "" ? icon : void 0
   };
 }
+var SLUG_PATTERN = "^[a-z][a-z0-9-]{0,62}$";
+var NAMESPACED_SLUG_PATTERN = "^[a-z][a-z0-9-]{0,62}:[a-z][a-z0-9-]{0,62}$";
+var SEMVER_PATTERN = "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?$";
+var CONFIG_KEY_PATTERN = "^[a-zA-Z][a-zA-Z0-9-]*$";
+var PATTERN_HINT = {
+  [SLUG_PATTERN]: 'lowercase kebab-case, such as "not-found"',
+  [NAMESPACED_SLUG_PATTERN]: '"<namespace>:<name>" in lowercase kebab-case, such as "core:http-request"',
+  [SEMVER_PATTERN]: 'a semantic version, such as "1.0.0"',
+  [CONFIG_KEY_PATTERN]: 'a letter, then letters, digits or "-", such as "postalCode"'
+};
+function nodeManifestProblems(nodes) {
+  const problems = [];
+  for (const [index, node] of nodes.entries()) {
+    const who = `node ${index + 1} (${typeof node.slug === "string" ? node.slug : "no slug"})`;
+    const check = (path, value, pattern) => {
+      if (value === void 0 || typeof value === "string" && new RegExp(pattern).test(value)) return;
+      problems.push(
+        `${who}: ${path} ${JSON.stringify(value)} is refused by the registry \u2014 it must match ${pattern} (${PATTERN_HINT[pattern]}).`
+      );
+    };
+    check("slug", node.slug, NAMESPACED_SLUG_PATTERN);
+    check("version", node.version, SEMVER_PATTERN);
+    for (const [i, port] of (node.outputs ?? []).entries()) {
+      check(`outputs[${i}].name`, port.name, SLUG_PATTERN);
+      check(`outputs[${i}].sourceFromConfig`, port.sourceFromConfig, SLUG_PATTERN);
+      check(`outputs[${i}].fallback.name`, port.fallback?.name, SLUG_PATTERN);
+    }
+    const checkField = (field, at) => {
+      check(`${at}.key`, field.key, CONFIG_KEY_PATTERN);
+      for (const [j, key] of (field.dependsOn ?? []).entries()) check(`${at}.dependsOn[${j}]`, key, CONFIG_KEY_PATTERN);
+      check(`${at}.showIf.key`, field.showIf?.key, CONFIG_KEY_PATTERN);
+      const types = field.credentialType;
+      if (Array.isArray(types)) {
+        for (const [j, type] of types.entries()) check(`${at}.credentialType[${j}]`, type, NAMESPACED_SLUG_PATTERN);
+      } else {
+        check(`${at}.credentialType`, types, NAMESPACED_SLUG_PATTERN);
+      }
+      walk(field.properties, `${at}.properties`);
+      if (field.items) checkField(field.items, `${at}.items`);
+    };
+    const walk = (fields, path) => {
+      for (const [i, field] of (fields ?? []).entries()) checkField(field, `${path}[${i}]`);
+    };
+    walk(node.config, "config");
+  }
+  return problems;
+}
 function buildManifest(nodes, credentials = [], templates = []) {
   const manifest = {
     manifestVersion: MANIFEST_VERSION,
@@ -213,6 +260,8 @@ async function runManifest() {
     console.warn(`\u26A0 ${w} This will be an error in the next major version.`);
   }
   const manifest = buildManifest(mod.NODES, credentials, templates);
+  const nameProblems = nodeManifestProblems(manifest.nodes);
+  if (nameProblems.length > 0) fail(nameProblems.join("\n"));
   const outDir = (0, import_node_path2.resolve)(projectRoot, "dist");
   const outFile = (0, import_node_path2.resolve)(outDir, "manifest.json");
   fs2.mkdirSync(outDir, { recursive: true });

package/dist/cli.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import {
   buildManifest,
+  nodeManifestProblems,
   outputWarnings,
   packageIconProblem,
   parsePackageMeta
-} from "./chunk-XO73F62E.js";
+} from "./chunk-CA6JVLLF.js";
 
 // src/cli.ts
 import * as fs2 from "fs";
@@ -112,6 +113,8 @@ async function runManifest() {
     console.warn(`\u26A0 ${w} This will be an error in the next major version.`);
   }
   const manifest = buildManifest(mod.NODES, credentials, templates);
+  const nameProblems = nodeManifestProblems(manifest.nodes);
+  if (nameProblems.length > 0) fail(nameProblems.join("\n"));
   const outDir = resolve2(projectRoot, "dist");
   const outFile = resolve2(outDir, "manifest.json");
   fs2.mkdirSync(outDir, { recursive: true });

package/dist/fetch.d.ts

@@ -65,6 +65,28 @@ export interface SafeFetchOptions extends RequestInit {
     /** Bind the request to the origin of the credential it carries. */
     credential?: SafeFetchCredential;
 }
+/**
+ * Whether the request behind a failed {@link safeFetch} call may have reached
+ * the host — `false` only when the call is known to have put nothing on the wire
+ * on any hop of any attempt, and `true` for every other error, an unknown one
+ * included. A node that writes reads it to decide whether a create may be
+ * repeated: when this is `false` nothing was sent, so nothing can have been
+ * created.
+ *
+ * It reads `meta.sent === false`, which `safeFetch` puts on what it throws in
+ * that case: a refused address — before the lookup or at connect time — a lookup
+ * that ran out of time, a header or URL that cannot be sent, a credential bound
+ * to another origin, and a connection that was refused, could not be resolved or
+ * reached, or timed out while connecting. The last group arrives as the runtime's
+ * own `TypeError('fetch failed')`, unwrapped as before, with the marker added. A
+ * cancellation is the caller's own reason and is never marked.
+ */
+export declare function mayHaveBeenSent(err: unknown): boolean;
+/**
+ * Make a request through the SSRF guard, under a time budget and an optional
+ * retry budget. A failure that left nothing on the wire says so with
+ * `meta.sent = false` — read it through {@link mayHaveBeenSent}.
+ */
 export declare function safeFetch(url: string | URL, options?: SafeFetchOptions): Promise<Response>;
 /**
  * Read a response body into an ArrayBuffer while enforcing a hard byte cap.

package/dist/index.cjs

@@ -33,6 +33,7 @@ __export(index_exports, {
   ApiKeyCredential: () => ApiKeyCredential,
   BaseCredential: () => BaseCredential,
   BasicAuthCredential: () => BasicAuthCredential,
+  CONFIG_KEY_PATTERN: () => CONFIG_KEY_PATTERN,
   DEFAULT_MAX_RESPONSE_BYTES: () => DEFAULT_MAX_RESPONSE_BYTES,
   DEFAULT_RETRY_ATTEMPTS: () => DEFAULT_RETRY_ATTEMPTS,
   DEFAULT_RETRY_DELAY_MS: () => DEFAULT_RETRY_DELAY_MS,
@@ -43,11 +44,14 @@ __export(index_exports, {
   MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES,
   MAX_RETRY_ATTEMPTS: () => MAX_RETRY_ATTEMPTS,
   MAX_TIMEOUT_MS: () => MAX_TIMEOUT_MS,
+  NAMESPACED_SLUG_PATTERN: () => NAMESPACED_SLUG_PATTERN,
   NodeError: () => NodeError,
   OAuth2AuthCodeCredential: () => OAuth2AuthCodeCredential,
   OAuth2ClientCredentialsCredential: () => OAuth2ClientCredentialsCredential,
   OPERATORS: () => OPERATORS,
   RetryableError: () => RetryableError,
+  SEMVER_PATTERN: () => SEMVER_PATTERN,
+  SLUG_PATTERN: () => SLUG_PATTERN,
   SimpleValueCredential: () => SimpleValueCredential,
   VALUELESS_OPERATORS: () => VALUELESS_OPERATORS,
   VPN_ERROR_CODES: () => VPN_ERROR_CODES,
@@ -66,6 +70,8 @@ __export(index_exports, {
   extractCredentialManifests: () => extractCredentialManifests,
   extractManifest: () => extractManifest,
   extractManifests: () => extractManifests,
+  guardRelaxedForLocalDev: () => guardRelaxedForLocalDev,
+  guardedLookup: () => guardedLookup,
   headerCrossesOrigin: () => headerCrossesOrigin,
   httpErrorResult: () => httpErrorResult,
   installAllowedTargets: () => installAllowedTargets,
@@ -77,6 +83,8 @@ __export(index_exports, {
   isOperator: () => isOperator,
   isVpnErrorCode: () => isVpnErrorCode,
   maxBytesConfigField: () => maxBytesConfigField,
+  mayHaveBeenSent: () => mayHaveBeenSent,
+  nodeManifestProblems: () => nodeManifestProblems,
   normalizeCredentialType: () => normalizeCredentialType,
   normalizeLocalized: () => normalizeLocalized,
   outputProblems: () => outputProblems,
@@ -370,6 +378,9 @@ function assertBranchNamed(node, result, config) {
   }
 }
 
+// src/fetch.ts
+var import_undici2 = require("undici");
+
 // src/ssrf.ts
 var import_node_diagnostics_channel = require("diagnostics_channel");
 var import_node_dns = __toESM(require("dns"), 1);
@@ -525,19 +536,25 @@ function guardRelaxedForLocalDev() {
   if (relaxed && !bypassNoticeLogged) {
     bypassNoticeLogged = true;
     console.warn(
-      "[ssrf] RVNXX_SSRF_ALLOW_PRIVATE is set: allowing private/loopback fetch targets. Intended for local development only."
+      "[ssrf] RVNXX_SSRF_ALLOW_PRIVATE is set: allowing private/loopback targets for web requests and connections. Intended for local development only."
     );
   }
   return relaxed;
 }
+function logBlocked(noun, host, address) {
+  console.warn(`[ssrf] blocked ${noun} to ${host}: resolves to private/reserved address ${address}`);
+}
 function blockedError(host, address) {
   if (host === address) {
     return new NodeError("BLOCKED_ADDRESS", `Blocked request to private or reserved address ${address}`, {
       status: 0
     });
   }
-  console.warn(`[ssrf] blocked request to ${host}: resolves to private/reserved address ${address}`);
-  return new NodeError("BLOCKED_ADDRESS", `Blocked request to ${host}: resolves to a private or reserved address`, {
+  logBlocked("request", host, address);
+  return refusedName(host);
+}
+function refusedName(host, noun = "request") {
+  return new NodeError("BLOCKED_ADDRESS", `Blocked ${noun} to ${host}: resolves to a private or reserved address`, {
     status: 0
   });
 }
@@ -619,6 +636,16 @@ function unreadablePortError(host) {
   );
 }
 function judgingLookup(port) {
+  return lookupJudgedFor(port, { noun: "request" }, (hostname) => new NodeError("BLOCKED_ADDRESS", `Could not resolve host: ${hostname}`, { status: 0 }));
+}
+function guardedLookup(port, options = {}) {
+  return lookupJudgedFor(
+    port,
+    options,
+    (hostname) => Object.assign(new Error(`getaddrinfo ENOTFOUND ${hostname}`), { code: "ENOTFOUND", hostname })
+  );
+}
+function lookupJudgedFor(port, { refusal, unroutable, noun = "connection" }, emptyAnswer) {
   return (hostname, options, callback) => {
     import_node_dns.default.lookup(hostname, { ...options, all: true }, (err, addresses) => {
       if (err) {
@@ -626,15 +653,18 @@ function judgingLookup(port) {
         return;
       }
       if (addresses.length === 0) {
-        callback(new NodeError("BLOCKED_ADDRESS", `Could not resolve host: ${hostname}`, { status: 0 }), "");
+        callback(emptyAnswer(hostname), "");
         return;
       }
       if (!guardRelaxedForLocalDev()) {
+        const host = hostname;
         for (const a of addresses) {
-          if (isBlockedAddress(a.address) && !isAllowedTarget(a.address, port)) {
-            callback(blockedError(normalizeHost(hostname), a.address), "");
-            return;
-          }
+          if (!isBlockedAddress(a.address)) continue;
+          const allowed = isAllowedTarget(a.address, port);
+          if (allowed && !unroutable) continue;
+          logBlocked(noun, host, a.address);
+          callback(allowed && unroutable ? unroutable(host) : refusal ? refusal(host) : refusedName(host, noun), "");
+          return;
         }
       }
       if (options.all) callback(null, addresses);
@@ -820,34 +850,132 @@ function credentialOriginRefusal(target, bound, hop) {
     { status: 0 }
   );
 }
-async function timedFetch(url, fetchOptions, ctxSignal, effectiveMs) {
+function attemptDeadline(ctxSignal, effectiveMs) {
   const ac = new AbortController();
-  const timer = setTimeout(() => ac.abort(), effectiveMs);
-  const signal = ctxSignal ? AbortSignal.any([ctxSignal, ac.signal]) : ac.signal;
+  let timer;
+  const arm = (message) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => ac.abort(new NodeError("TIMEOUT", message)), effectiveMs);
+  };
+  arm(`Request timed out after ${effectiveMs}ms`);
+  return {
+    signal: ctxSignal ? AbortSignal.any([ctxSignal, ac.signal]) : ac.signal,
+    expired: () => ac.signal.aborted,
+    reason: () => ac.signal.reason,
+    clear: () => clearTimeout(timer),
+    awaitChunk: () => arm(`The answer sent nothing for ${effectiveMs}ms`)
+  };
+}
+function attemptFailure(err, ctxSignal, deadline) {
+  if (ctxSignal?.aborted) return ctxSignal.reason;
+  if (deadline.expired()) return deadline.reason();
+  return err;
+}
+function answerUnderDeadline(res, ctxSignal, deadline) {
+  if (!res.body) return rebuilt(res, null) ?? asRuntimeResponse(res);
+  let reader;
+  const body = new ReadableStream(
+    {
+      async pull(controller) {
+        reader ??= res.body.getReader();
+        deadline.awaitChunk();
+        try {
+          const { done, value } = await reader.read();
+          if (done) controller.close();
+          else controller.enqueue(value);
+        } catch (err) {
+          controller.error(attemptFailure(err, ctxSignal, deadline));
+        } finally {
+          deadline.clear();
+        }
+      },
+      cancel(reason) {
+        deadline.clear();
+        return reader ? reader.cancel(reason) : res.body?.cancel(reason);
+      }
+    },
+    // Read nothing ahead of the caller: the limit times the caller's waits, not
+    // a buffer filling while nobody reads.
+    { highWaterMark: 0 }
+  );
+  return rebuilt(res, body) ?? asRuntimeResponse(res);
+}
+function rebuilt(res, body) {
+  try {
+    return withUrl(new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers }), res.url);
+  } catch {
+    return void 0;
+  }
+}
+function asRuntimeResponse(res) {
+  return withUrl(withStatusLine(new Response(res.body, { headers: res.headers }), res), res.url);
+}
+function withStatusLine(answer, from) {
+  const clone = answer.clone.bind(answer);
+  Object.defineProperties(answer, {
+    status: { value: from.status },
+    statusText: { value: from.statusText },
+    ok: { value: from.ok },
+    clone: { value: () => withStatusLine(clone(), from), configurable: true }
+  });
+  return answer;
+}
+function withUrl(answer, url) {
+  const clone = answer.clone.bind(answer);
+  Object.defineProperty(answer, "url", { value: url });
+  Object.defineProperty(answer, "clone", { value: () => withUrl(clone(), url) });
+  return answer;
+}
+var runtimeFetch = globalThis.fetch;
+function transport() {
+  const current = globalThis.fetch;
+  return current === runtimeFetch ? import_undici2.fetch : current;
+}
+var NEVER_CONNECTED = /* @__PURE__ */ new Set(["ENOTFOUND", "EAI_AGAIN", "UND_ERR_CONNECT_TIMEOUT"]);
+var REFUSED_WHILE_CONNECTING = /* @__PURE__ */ new Set(["ECONNREFUSED", "EHOSTUNREACH", "ENETUNREACH"]);
+function connectFailed(e) {
+  if (typeof e?.code !== "string") return false;
+  return NEVER_CONNECTED.has(e.code) || REFUSED_WHILE_CONNECTING.has(e.code) && e.syscall === "connect";
+}
+function neverConnected(err) {
+  const cause = err?.cause;
+  if (!cause) return false;
+  if (Array.isArray(cause.errors) && cause.errors.length > 0) return cause.errors.every(connectFailed);
+  return connectFailed(cause);
+}
+function markUnsent(err) {
+  if (typeof err !== "object" || err === null) return;
+  const meta = err.meta;
+  const sent = { ...typeof meta === "object" && meta !== null ? meta : {}, sent: false };
   try {
-    return await fetch(url, { ...fetchOptions, signal, dispatcher: guardedDispatcher() });
+    Object.defineProperty(err, "meta", { value: sent, writable: true, configurable: true, enumerable: true });
+  } catch {
+  }
+}
+function mayHaveBeenSent(err) {
+  const meta = err?.meta;
+  return meta?.sent !== false;
+}
+async function timedFetch(url, fetchOptions, ctxSignal, deadline, wire) {
+  try {
+    const send = transport();
+    const res = await send(url, { ...fetchOptions, signal: deadline.signal, dispatcher: guardedDispatcher() });
+    wire.maybeSent = true;
+    return res;
   } catch (err) {
     const blocked = connectionRefusal(err);
     if (blocked) throw blocked;
-    if (ctxSignal?.aborted) throw ctxSignal.reason;
-    if (ac.signal.aborted) throw new NodeError("TIMEOUT", `Request timed out after ${effectiveMs}ms`);
-    throw err;
-  } finally {
-    clearTimeout(timer);
+    if (!neverConnected(err)) wire.maybeSent = true;
+    throw attemptFailure(err, ctxSignal, deadline);
   }
 }
-async function guardUrl(url, ctxSignal, effectiveMs) {
-  const ac = new AbortController();
-  const timer = setTimeout(() => ac.abort(), effectiveMs);
-  const signal = ctxSignal ? AbortSignal.any([ctxSignal, ac.signal]) : ac.signal;
+async function guardUrl(url, ctxSignal, deadline, effectiveMs) {
   try {
-    await assertPublicUrl(url, { signal });
+    await assertPublicUrl(url, { signal: deadline.signal });
   } catch (err) {
     if (ctxSignal?.aborted) throw ctxSignal.reason;
-    if (ac.signal.aborted) throw new NodeError("TIMEOUT", `DNS resolution timed out after ${effectiveMs}ms`);
+    if (deadline.expired()) throw new NodeError("TIMEOUT", `DNS resolution timed out after ${effectiveMs}ms`);
     throw err;
-  } finally {
-    clearTimeout(timer);
   }
 }
 function hasContent(body) {
@@ -868,17 +996,28 @@ function refuseUserinfo(url, status = 0) {
     );
   }
 }
-async function guardedFetch(url, fetchOptions, ctxSignal, effectiveMs, binding) {
+async function guardedFetch(url, fetchOptions, ctxSignal, effectiveMs, wire, binding) {
+  const deadline = attemptDeadline(ctxSignal, effectiveMs);
+  try {
+    const res = await followHops(url, fetchOptions, ctxSignal, deadline, effectiveMs, wire, binding);
+    deadline.clear();
+    return answerUnderDeadline(res, ctxSignal, deadline);
+  } catch (err) {
+    deadline.clear();
+    throw err;
+  }
+}
+async function followHops(url, fetchOptions, ctxSignal, deadline, effectiveMs, wire, binding) {
   let currentUrl = url;
   let currentInit = { ...fetchOptions, redirect: "manual" };
-  await guardUrl(currentUrl, ctxSignal, effectiveMs);
+  await guardUrl(currentUrl, ctxSignal, deadline, effectiveMs);
   for (let hop = 0; ; hop++) {
     const release = guardConnectionsTo(
       currentUrl instanceof URL ? currentUrl : new URL(currentUrl)
     );
     let res;
     try {
-      res = await timedFetch(currentUrl, currentInit, ctxSignal, effectiveMs);
+      res = await timedFetch(currentUrl, currentInit, ctxSignal, deadline, wire);
     } finally {
       release();
     }
@@ -920,7 +1059,7 @@ async function guardedFetch(url, fetchOptions, ctxSignal, effectiveMs, binding)
         { status: 0 }
       );
     }
-    await guardUrl(nextUrl, ctxSignal, effectiveMs);
+    await guardUrl(nextUrl, ctxSignal, deadline, effectiveMs);
     if (binding && nextUrl.origin !== binding.origin) {
       for (const name of [...headers.keys()]) headers.delete(name);
     } else if (nextUrl.origin !== base.origin) {
@@ -933,6 +1072,15 @@ async function guardedFetch(url, fetchOptions, ctxSignal, effectiveMs, binding)
   }
 }
 async function safeFetch(url, options = {}) {
+  const wire = { maybeSent: false };
+  try {
+    return await sendWithin(url, options, wire);
+  } catch (err) {
+    if (!wire.maybeSent && err !== options.signal?.reason) markUnsent(err);
+    throw err;
+  }
+}
+async function sendWithin(url, options, wire) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, signal: ctxSignal, retry, credential, ...fetchOptions } = options;
   const effectiveMs = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.min(timeoutMs, MAX_TIMEOUT_MS) : DEFAULT_TIMEOUT_MS;
   const rawAttempts = retry?.attempts ?? DEFAULT_RETRY_ATTEMPTS;
@@ -957,7 +1105,7 @@ async function safeFetch(url, options = {}) {
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     if (ctxSignal?.aborted) throw ctxSignal.reason;
     try {
-      return await guardedFetch(url, fetchOptions, ctxSignal, effectiveMs, binding);
+      return await guardedFetch(url, fetchOptions, ctxSignal, effectiveMs, wire, binding);
     } catch (err) {
       if (ctxSignal?.aborted) throw ctxSignal.reason;
       if (err instanceof NodeError && (err.code === "BLOCKED_ADDRESS" || err.code === "TOO_MANY_REDIRECTS" || err.code === "CREDENTIAL_ORIGIN" || err.code === "INVALID_URL")) {
@@ -1068,8 +1216,8 @@ function timeoutConfigField(opts) {
     key: "timeoutMs",
     label: { en: "Timeout (ms)", de: "Zeitlimit (ms)" },
     description: {
-      en: "How long one attempt may take before it fails as a timeout. Counted per attempt and per redirect hop, not across the whole call.",
-      de: "Wie lange ein einzelner Versuch dauern darf, bevor er als Zeit\xFCberschreitung fehlschl\xE4gt. Gilt je Versuch und je Weiterleitung, nicht f\xFCr den gesamten Aufruf."
+      en: "How long one attempt may wait for an answer to start, redirects included, and how long the answer may then go silent before it fails as a timeout. An answer that keeps arriving is not cut off. Each retry gets the time again.",
+      de: "Wie lange ein einzelner Versuch auf den Beginn einer Antwort warten darf, Weiterleitungen eingeschlossen, und wie lange die Antwort danach stocken darf, bevor sie als Zeit\xFCberschreitung fehlschl\xE4gt. Eine Antwort, die weiter eintrifft, wird nicht abgebrochen. Jede Wiederholung bekommt die Zeit erneut."
     },
     type: "number",
     default: opts?.default ?? DEFAULT_TIMEOUT_MS,
@@ -1192,6 +1340,53 @@ function parsePackageMeta(raw) {
     icon: icon !== "" ? icon : void 0
   };
 }
+var SLUG_PATTERN = "^[a-z][a-z0-9-]{0,62}$";
+var NAMESPACED_SLUG_PATTERN = "^[a-z][a-z0-9-]{0,62}:[a-z][a-z0-9-]{0,62}$";
+var SEMVER_PATTERN = "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?$";
+var CONFIG_KEY_PATTERN = "^[a-zA-Z][a-zA-Z0-9-]*$";
+var PATTERN_HINT = {
+  [SLUG_PATTERN]: 'lowercase kebab-case, such as "not-found"',
+  [NAMESPACED_SLUG_PATTERN]: '"<namespace>:<name>" in lowercase kebab-case, such as "core:http-request"',
+  [SEMVER_PATTERN]: 'a semantic version, such as "1.0.0"',
+  [CONFIG_KEY_PATTERN]: 'a letter, then letters, digits or "-", such as "postalCode"'
+};
+function nodeManifestProblems(nodes) {
+  const problems = [];
+  for (const [index, node] of nodes.entries()) {
+    const who = `node ${index + 1} (${typeof node.slug === "string" ? node.slug : "no slug"})`;
+    const check = (path, value, pattern) => {
+      if (value === void 0 || typeof value === "string" && new RegExp(pattern).test(value)) return;
+      problems.push(
+        `${who}: ${path} ${JSON.stringify(value)} is refused by the registry \u2014 it must match ${pattern} (${PATTERN_HINT[pattern]}).`
+      );
+    };
+    check("slug", node.slug, NAMESPACED_SLUG_PATTERN);
+    check("version", node.version, SEMVER_PATTERN);
+    for (const [i, port] of (node.outputs ?? []).entries()) {
+      check(`outputs[${i}].name`, port.name, SLUG_PATTERN);
+      check(`outputs[${i}].sourceFromConfig`, port.sourceFromConfig, SLUG_PATTERN);
+      check(`outputs[${i}].fallback.name`, port.fallback?.name, SLUG_PATTERN);
+    }
+    const checkField = (field, at) => {
+      check(`${at}.key`, field.key, CONFIG_KEY_PATTERN);
+      for (const [j, key] of (field.dependsOn ?? []).entries()) check(`${at}.dependsOn[${j}]`, key, CONFIG_KEY_PATTERN);
+      check(`${at}.showIf.key`, field.showIf?.key, CONFIG_KEY_PATTERN);
+      const types = field.credentialType;
+      if (Array.isArray(types)) {
+        for (const [j, type] of types.entries()) check(`${at}.credentialType[${j}]`, type, NAMESPACED_SLUG_PATTERN);
+      } else {
+        check(`${at}.credentialType`, types, NAMESPACED_SLUG_PATTERN);
+      }
+      walk(field.properties, `${at}.properties`);
+      if (field.items) checkField(field.items, `${at}.items`);
+    };
+    const walk = (fields, path) => {
+      for (const [i, field] of (fields ?? []).entries()) checkField(field, `${path}[${i}]`);
+    };
+    walk(node.config, "config");
+  }
+  return problems;
+}
 function buildManifest(nodes, credentials = [], templates = []) {
   const manifest = {
     manifestVersion: MANIFEST_VERSION,
@@ -1476,6 +1671,7 @@ function base64Url(buf) {
   ApiKeyCredential,
   BaseCredential,
   BasicAuthCredential,
+  CONFIG_KEY_PATTERN,
   DEFAULT_MAX_RESPONSE_BYTES,
   DEFAULT_RETRY_ATTEMPTS,
   DEFAULT_RETRY_DELAY_MS,
@@ -1486,11 +1682,14 @@ function base64Url(buf) {
   MAX_RESPONSE_BYTES,
   MAX_RETRY_ATTEMPTS,
   MAX_TIMEOUT_MS,
+  NAMESPACED_SLUG_PATTERN,
   NodeError,
   OAuth2AuthCodeCredential,
   OAuth2ClientCredentialsCredential,
   OPERATORS,
   RetryableError,
+  SEMVER_PATTERN,
+  SLUG_PATTERN,
   SimpleValueCredential,
   VALUELESS_OPERATORS,
   VPN_ERROR_CODES,
@@ -1509,6 +1708,8 @@ function base64Url(buf) {
   extractCredentialManifests,
   extractManifest,
   extractManifests,
+  guardRelaxedForLocalDev,
+  guardedLookup,
   headerCrossesOrigin,
   httpErrorResult,
   installAllowedTargets,
@@ -1520,6 +1721,8 @@ function base64Url(buf) {
   isOperator,
   isVpnErrorCode,
   maxBytesConfigField,
+  mayHaveBeenSent,
+  nodeManifestProblems,
   normalizeCredentialType,
   normalizeLocalized,
   outputProblems,

package/dist/index.d.ts

@@ -8,8 +8,8 @@ export * from './nodeErrors.js';
 export * from './extract.js';
 export * from './branches.js';
 export * from './fetch.js';
-export { assertPublicUrl, isBlockedAddress } from './ssrf.js';
-export type { LookupAddress, LookupFn } from './ssrf.js';
+export { assertPublicUrl, guardedLookup, guardRelaxedForLocalDev, isBlockedAddress } from './ssrf.js';
+export type { GuardedLookupOptions, LookupAddress, LookupFn } from './ssrf.js';
 export { allowedTargets, installAllowedTargets, isAllowedTarget } from './allowedTargets.js';
 export * from './retry.js';
 export * from './manifest.js';

package/dist/index.js

@@ -1,5 +1,9 @@
 import {
+  CONFIG_KEY_PATTERN,
   MANIFEST_VERSION,
+  NAMESPACED_SLUG_PATTERN,
+  SEMVER_PATTERN,
+  SLUG_PATTERN,
   assertBranchNamed,
   buildManifest,
   extractCredentialManifest,
@@ -7,11 +11,12 @@ import {
   extractManifest,
   extractManifests,
   isMultiPort,
+  nodeManifestProblems,
   outputProblems,
   outputWarnings,
   packageIconProblem,
   parsePackageMeta
-} from "./chunk-XO73F62E.js";
+} from "./chunk-CA6JVLLF.js";
 
 // src/types.ts
 function isNodeWithIteration(node) {
@@ -212,6 +217,9 @@ function errorPort(opts = {}) {
   };
 }
 
+// src/fetch.ts
+import { fetch as undiciFetch } from "undici";
+
 // src/ssrf.ts
 import { subscribe } from "diagnostics_channel";
 import dns from "dns";
@@ -367,19 +375,25 @@ function guardRelaxedForLocalDev() {
   if (relaxed && !bypassNoticeLogged) {
     bypassNoticeLogged = true;
     console.warn(
-      "[ssrf] RVNXX_SSRF_ALLOW_PRIVATE is set: allowing private/loopback fetch targets. Intended for local development only."
+      "[ssrf] RVNXX_SSRF_ALLOW_PRIVATE is set: allowing private/loopback targets for web requests and connections. Intended for local development only."
     );
   }
   return relaxed;
 }
+function logBlocked(noun, host, address) {
+  console.warn(`[ssrf] blocked ${noun} to ${host}: resolves to private/reserved address ${address}`);
+}
 function blockedError(host, address) {
   if (host === address) {
     return new NodeError("BLOCKED_ADDRESS", `Blocked request to private or reserved address ${address}`, {
       status: 0
     });
   }
-  console.warn(`[ssrf] blocked request to ${host}: resolves to private/reserved address ${address}`);
-  return new NodeError("BLOCKED_ADDRESS", `Blocked request to ${host}: resolves to a private or reserved address`, {
+  logBlocked("request", host, address);
+  return refusedName(host);
+}
+function refusedName(host, noun = "request") {
+  return new NodeError("BLOCKED_ADDRESS", `Blocked ${noun} to ${host}: resolves to a private or reserved address`, {
     status: 0
   });
 }
@@ -461,6 +475,16 @@ function unreadablePortError(host) {
   );
 }
 function judgingLookup(port) {
+  return lookupJudgedFor(port, { noun: "request" }, (hostname) => new NodeError("BLOCKED_ADDRESS", `Could not resolve host: ${hostname}`, { status: 0 }));
+}
+function guardedLookup(port, options = {}) {
+  return lookupJudgedFor(
+    port,
+    options,
+    (hostname) => Object.assign(new Error(`getaddrinfo ENOTFOUND ${hostname}`), { code: "ENOTFOUND", hostname })
+  );
+}
+function lookupJudgedFor(port, { refusal, unroutable, noun = "connection" }, emptyAnswer) {
   return (hostname, options, callback) => {
     dns.lookup(hostname, { ...options, all: true }, (err, addresses) => {
       if (err) {
@@ -468,15 +492,18 @@ function judgingLookup(port) {
         return;
       }
       if (addresses.length === 0) {
-        callback(new NodeError("BLOCKED_ADDRESS", `Could not resolve host: ${hostname}`, { status: 0 }), "");
+        callback(emptyAnswer(hostname), "");
         return;
       }
       if (!guardRelaxedForLocalDev()) {
+        const host = hostname;
         for (const a of addresses) {
-          if (isBlockedAddress(a.address) && !isAllowedTarget(a.address, port)) {
-            callback(blockedError(normalizeHost(hostname), a.address), "");
-            return;
-          }
+          if (!isBlockedAddress(a.address)) continue;
+          const allowed = isAllowedTarget(a.address, port);
+          if (allowed && !unroutable) continue;
+          logBlocked(noun, host, a.address);
+          callback(allowed && unroutable ? unroutable(host) : refusal ? refusal(host) : refusedName(host, noun), "");
+          return;
         }
       }
       if (options.all) callback(null, addresses);
@@ -662,34 +689,132 @@ function credentialOriginRefusal(target, bound, hop) {
     { status: 0 }
   );
 }
-async function timedFetch(url, fetchOptions, ctxSignal, effectiveMs) {
+function attemptDeadline(ctxSignal, effectiveMs) {
   const ac = new AbortController();
-  const timer = setTimeout(() => ac.abort(), effectiveMs);
-  const signal = ctxSignal ? AbortSignal.any([ctxSignal, ac.signal]) : ac.signal;
+  let timer;
+  const arm = (message) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => ac.abort(new NodeError("TIMEOUT", message)), effectiveMs);
+  };
+  arm(`Request timed out after ${effectiveMs}ms`);
+  return {
+    signal: ctxSignal ? AbortSignal.any([ctxSignal, ac.signal]) : ac.signal,
+    expired: () => ac.signal.aborted,
+    reason: () => ac.signal.reason,
+    clear: () => clearTimeout(timer),
+    awaitChunk: () => arm(`The answer sent nothing for ${effectiveMs}ms`)
+  };
+}
+function attemptFailure(err, ctxSignal, deadline) {
+  if (ctxSignal?.aborted) return ctxSignal.reason;
+  if (deadline.expired()) return deadline.reason();
+  return err;
+}
+function answerUnderDeadline(res, ctxSignal, deadline) {
+  if (!res.body) return rebuilt(res, null) ?? asRuntimeResponse(res);
+  let reader;
+  const body = new ReadableStream(
+    {
+      async pull(controller) {
+        reader ??= res.body.getReader();
+        deadline.awaitChunk();
+        try {
+          const { done, value } = await reader.read();
+          if (done) controller.close();
+          else controller.enqueue(value);
+        } catch (err) {
+          controller.error(attemptFailure(err, ctxSignal, deadline));
+        } finally {
+          deadline.clear();
+        }
+      },
+      cancel(reason) {
+        deadline.clear();
+        return reader ? reader.cancel(reason) : res.body?.cancel(reason);
+      }
+    },
+    // Read nothing ahead of the caller: the limit times the caller's waits, not
+    // a buffer filling while nobody reads.
+    { highWaterMark: 0 }
+  );
+  return rebuilt(res, body) ?? asRuntimeResponse(res);
+}
+function rebuilt(res, body) {
   try {
-    return await fetch(url, { ...fetchOptions, signal, dispatcher: guardedDispatcher() });
+    return withUrl(new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers }), res.url);
+  } catch {
+    return void 0;
+  }
+}
+function asRuntimeResponse(res) {
+  return withUrl(withStatusLine(new Response(res.body, { headers: res.headers }), res), res.url);
+}
+function withStatusLine(answer, from) {
+  const clone = answer.clone.bind(answer);
+  Object.defineProperties(answer, {
+    status: { value: from.status },
+    statusText: { value: from.statusText },
+    ok: { value: from.ok },
+    clone: { value: () => withStatusLine(clone(), from), configurable: true }
+  });
+  return answer;
+}
+function withUrl(answer, url) {
+  const clone = answer.clone.bind(answer);
+  Object.defineProperty(answer, "url", { value: url });
+  Object.defineProperty(answer, "clone", { value: () => withUrl(clone(), url) });
+  return answer;
+}
+var runtimeFetch = globalThis.fetch;
+function transport() {
+  const current = globalThis.fetch;
+  return current === runtimeFetch ? undiciFetch : current;
+}
+var NEVER_CONNECTED = /* @__PURE__ */ new Set(["ENOTFOUND", "EAI_AGAIN", "UND_ERR_CONNECT_TIMEOUT"]);
+var REFUSED_WHILE_CONNECTING = /* @__PURE__ */ new Set(["ECONNREFUSED", "EHOSTUNREACH", "ENETUNREACH"]);
+function connectFailed(e) {
+  if (typeof e?.code !== "string") return false;
+  return NEVER_CONNECTED.has(e.code) || REFUSED_WHILE_CONNECTING.has(e.code) && e.syscall === "connect";
+}
+function neverConnected(err) {
+  const cause = err?.cause;
+  if (!cause) return false;
+  if (Array.isArray(cause.errors) && cause.errors.length > 0) return cause.errors.every(connectFailed);
+  return connectFailed(cause);
+}
+function markUnsent(err) {
+  if (typeof err !== "object" || err === null) return;
+  const meta = err.meta;
+  const sent = { ...typeof meta === "object" && meta !== null ? meta : {}, sent: false };
+  try {
+    Object.defineProperty(err, "meta", { value: sent, writable: true, configurable: true, enumerable: true });
+  } catch {
+  }
+}
+function mayHaveBeenSent(err) {
+  const meta = err?.meta;
+  return meta?.sent !== false;
+}
+async function timedFetch(url, fetchOptions, ctxSignal, deadline, wire) {
+  try {
+    const send = transport();
+    const res = await send(url, { ...fetchOptions, signal: deadline.signal, dispatcher: guardedDispatcher() });
+    wire.maybeSent = true;
+    return res;
   } catch (err) {
     const blocked = connectionRefusal(err);
     if (blocked) throw blocked;
-    if (ctxSignal?.aborted) throw ctxSignal.reason;
-    if (ac.signal.aborted) throw new NodeError("TIMEOUT", `Request timed out after ${effectiveMs}ms`);
-    throw err;
-  } finally {
-    clearTimeout(timer);
+    if (!neverConnected(err)) wire.maybeSent = true;
+    throw attemptFailure(err, ctxSignal, deadline);
   }
 }
-async function guardUrl(url, ctxSignal, effectiveMs) {
-  const ac = new AbortController();
-  const timer = setTimeout(() => ac.abort(), effectiveMs);
-  const signal = ctxSignal ? AbortSignal.any([ctxSignal, ac.signal]) : ac.signal;
+async function guardUrl(url, ctxSignal, deadline, effectiveMs) {
   try {
-    await assertPublicUrl(url, { signal });
+    await assertPublicUrl(url, { signal: deadline.signal });
   } catch (err) {
     if (ctxSignal?.aborted) throw ctxSignal.reason;
-    if (ac.signal.aborted) throw new NodeError("TIMEOUT", `DNS resolution timed out after ${effectiveMs}ms`);
+    if (deadline.expired()) throw new NodeError("TIMEOUT", `DNS resolution timed out after ${effectiveMs}ms`);
     throw err;
-  } finally {
-    clearTimeout(timer);
   }
 }
 function hasContent(body) {
@@ -710,17 +835,28 @@ function refuseUserinfo(url, status = 0) {
     );
   }
 }
-async function guardedFetch(url, fetchOptions, ctxSignal, effectiveMs, binding) {
+async function guardedFetch(url, fetchOptions, ctxSignal, effectiveMs, wire, binding) {
+  const deadline = attemptDeadline(ctxSignal, effectiveMs);
+  try {
+    const res = await followHops(url, fetchOptions, ctxSignal, deadline, effectiveMs, wire, binding);
+    deadline.clear();
+    return answerUnderDeadline(res, ctxSignal, deadline);
+  } catch (err) {
+    deadline.clear();
+    throw err;
+  }
+}
+async function followHops(url, fetchOptions, ctxSignal, deadline, effectiveMs, wire, binding) {
   let currentUrl = url;
   let currentInit = { ...fetchOptions, redirect: "manual" };
-  await guardUrl(currentUrl, ctxSignal, effectiveMs);
+  await guardUrl(currentUrl, ctxSignal, deadline, effectiveMs);
   for (let hop = 0; ; hop++) {
     const release = guardConnectionsTo(
       currentUrl instanceof URL ? currentUrl : new URL(currentUrl)
     );
     let res;
     try {
-      res = await timedFetch(currentUrl, currentInit, ctxSignal, effectiveMs);
+      res = await timedFetch(currentUrl, currentInit, ctxSignal, deadline, wire);
     } finally {
       release();
     }
@@ -762,7 +898,7 @@ async function guardedFetch(url, fetchOptions, ctxSignal, effectiveMs, binding)
         { status: 0 }
       );
     }
-    await guardUrl(nextUrl, ctxSignal, effectiveMs);
+    await guardUrl(nextUrl, ctxSignal, deadline, effectiveMs);
     if (binding && nextUrl.origin !== binding.origin) {
       for (const name of [...headers.keys()]) headers.delete(name);
     } else if (nextUrl.origin !== base.origin) {
@@ -775,6 +911,15 @@ async function guardedFetch(url, fetchOptions, ctxSignal, effectiveMs, binding)
   }
 }
 async function safeFetch(url, options = {}) {
+  const wire = { maybeSent: false };
+  try {
+    return await sendWithin(url, options, wire);
+  } catch (err) {
+    if (!wire.maybeSent && err !== options.signal?.reason) markUnsent(err);
+    throw err;
+  }
+}
+async function sendWithin(url, options, wire) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS, signal: ctxSignal, retry, credential, ...fetchOptions } = options;
   const effectiveMs = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.min(timeoutMs, MAX_TIMEOUT_MS) : DEFAULT_TIMEOUT_MS;
   const rawAttempts = retry?.attempts ?? DEFAULT_RETRY_ATTEMPTS;
@@ -799,7 +944,7 @@ async function safeFetch(url, options = {}) {
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     if (ctxSignal?.aborted) throw ctxSignal.reason;
     try {
-      return await guardedFetch(url, fetchOptions, ctxSignal, effectiveMs, binding);
+      return await guardedFetch(url, fetchOptions, ctxSignal, effectiveMs, wire, binding);
     } catch (err) {
       if (ctxSignal?.aborted) throw ctxSignal.reason;
       if (err instanceof NodeError && (err.code === "BLOCKED_ADDRESS" || err.code === "TOO_MANY_REDIRECTS" || err.code === "CREDENTIAL_ORIGIN" || err.code === "INVALID_URL")) {
@@ -910,8 +1055,8 @@ function timeoutConfigField(opts) {
     key: "timeoutMs",
     label: { en: "Timeout (ms)", de: "Zeitlimit (ms)" },
     description: {
-      en: "How long one attempt may take before it fails as a timeout. Counted per attempt and per redirect hop, not across the whole call.",
-      de: "Wie lange ein einzelner Versuch dauern darf, bevor er als Zeit\xFCberschreitung fehlschl\xE4gt. Gilt je Versuch und je Weiterleitung, nicht f\xFCr den gesamten Aufruf."
+      en: "How long one attempt may wait for an answer to start, redirects included, and how long the answer may then go silent before it fails as a timeout. An answer that keeps arriving is not cut off. Each retry gets the time again.",
+      de: "Wie lange ein einzelner Versuch auf den Beginn einer Antwort warten darf, Weiterleitungen eingeschlossen, und wie lange die Antwort danach stocken darf, bevor sie als Zeit\xFCberschreitung fehlschl\xE4gt. Eine Antwort, die weiter eintrifft, wird nicht abgebrochen. Jede Wiederholung bekommt die Zeit erneut."
     },
     type: "number",
     default: opts?.default ?? DEFAULT_TIMEOUT_MS,
@@ -1282,6 +1427,7 @@ export {
   ApiKeyCredential,
   BaseCredential,
   BasicAuthCredential,
+  CONFIG_KEY_PATTERN,
   DEFAULT_MAX_RESPONSE_BYTES,
   DEFAULT_RETRY_ATTEMPTS,
   DEFAULT_RETRY_DELAY_MS,
@@ -1292,11 +1438,14 @@ export {
   MAX_RESPONSE_BYTES,
   MAX_RETRY_ATTEMPTS,
   MAX_TIMEOUT_MS,
+  NAMESPACED_SLUG_PATTERN,
   NodeError,
   OAuth2AuthCodeCredential,
   OAuth2ClientCredentialsCredential,
   OPERATORS,
   RetryableError,
+  SEMVER_PATTERN,
+  SLUG_PATTERN,
   SimpleValueCredential,
   VALUELESS_OPERATORS,
   VPN_ERROR_CODES,
@@ -1315,6 +1464,8 @@ export {
   extractCredentialManifests,
   extractManifest,
   extractManifests,
+  guardRelaxedForLocalDev,
+  guardedLookup,
   headerCrossesOrigin,
   httpErrorResult,
   installAllowedTargets,
@@ -1326,6 +1477,8 @@ export {
   isOperator,
   isVpnErrorCode,
   maxBytesConfigField,
+  mayHaveBeenSent,
+  nodeManifestProblems,
   normalizeCredentialType,
   normalizeLocalized,
   outputProblems,

package/dist/manifest.d.ts

@@ -73,6 +73,31 @@ export declare function packageIconProblem(icon: string | undefined): string | u
  * enforces that on upload; this is a typed, lenient read for tooling.
  */
 export declare function parsePackageMeta(raw: unknown): NodePackageMeta;
+/**
+ * The name patterns the registry enforces on a node's manifest when a package is
+ * uploaded (PO-744), as written in the integrations service's node schema
+ * (`app/Support/Schema/Versions/Node/V0DraftSchema.php`, read at `973b28c2`, 27
+ * October 2026), under the same names. A copy, not a shared source: a change on
+ * either side has to be made on both. They are exported as the schema's text, so
+ * a test on the other side can compare them byte for byte.
+ */
+/** A port name, `sourceFromConfig` and `fallback.name`: lowercase kebab-case. */
+export declare const SLUG_PATTERN = "^[a-z][a-z0-9-]{0,62}$";
+/** A node's `slug`, and a credential type a setting names: `<namespace>:<slug>`. */
+export declare const NAMESPACED_SLUG_PATTERN = "^[a-z][a-z0-9-]{0,62}:[a-z][a-z0-9-]{0,62}$";
+/** A node's `version`. */
+export declare const SEMVER_PATTERN = "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?$";
+/** A setting's `key`, `dependsOn[]` and `showIf.key`: camelCase is allowed here, unlike in a port name. */
+export declare const CONFIG_KEY_PATTERN = "^[a-zA-Z][a-zA-Z0-9-]*$";
+/**
+ * Why the registry would refuse these nodes' names on upload, one line per value,
+ * or `[]` when it would accept them (PO-744). Each line names the node, the path
+ * of the field, the value and the pattern. Only values that are present are
+ * judged: a missing slug or version is the schema's other rule, and a port may
+ * leave its name out. Settings are walked into `properties` and `items` at any
+ * depth; the schema allows less, so none is missed.
+ */
+export declare function nodeManifestProblems(nodes: readonly INodeDescription[]): string[];
 /**
  * Builds the manifest envelope from a package's `NODES` (and optional
  * `CREDENTIALS` / `TEMPLATES`) exports. The result is what gets written to

package/dist/ssrf.d.ts

@@ -1,3 +1,4 @@
+import { type LookupFunction } from 'node:net';
 import { Agent } from 'undici';
 import { NodeError } from './errors.js';
 /**
@@ -40,6 +41,44 @@ export declare const ssrfResolver: {
  * Promised behaviour: specs/ssrf-guard.md (AC-9, AC-11, AC-19).
  */
 export declare function isBlockedAddress(ip: string): boolean;
+export declare function guardRelaxedForLocalDev(): boolean;
+/** How a connection that `safeFetch` does not make reports what {@link guardedLookup} decides. */
+export interface GuardedLookupOptions {
+    /**
+     * The error a refused name fails with. It is handed to the caller and may reach
+     * a workflow author, so it names the host and never an address it resolved to.
+     * Default: `Blocked <noun> to <host>: resolves to a private or reserved
+     * address`, code `BLOCKED_ADDRESS` — `safeFetch`'s words with this lookup's noun.
+     */
+    refusal?: (host: string) => Error;
+    /**
+     * For a client a VPN route cannot carry: a private address on the run's
+     * allow-list is refused with this error instead of passing. Absent, the
+     * allow-list applies as it does to `safeFetch`.
+     */
+    unroutable?: (host: string) => Error;
+    /** The noun of the operator's log line, `[ssrf] blocked <noun> to …`, and of the default refusal. Default `'connection'`. */
+    noun?: 'request' | 'connection';
+}
+/**
+ * A socket lookup, shaped like `net.LookupFunction`, that judges every address a
+ * name resolves to by the rule `safeFetch` connects under (PO-698) — for a client
+ * that opens its own socket (FTP, SFTP, a plain `node:http` stream) and so never
+ * meets `safeFetch`. Pass it as the socket's `lookup` with the port it connects to.
+ *
+ * The check runs inside the socket's own name resolution, so the socket can only
+ * reach addresses that were judged, with no second lookup a changed DNS answer
+ * could slip through, and Node still tries every approved address in turn. A
+ * name is refused when any address is private or reserved and not on the run's
+ * allow-list for `port` (PO-828); the refusal is logged for the operator; the
+ * local-development switch ({@link guardRelaxedForLocalDev}) relaxes it. A name
+ * that does not resolve fails as the resolver said, not as a refusal.
+ *
+ * **Node calls no lookup for a host written as an address**, so a literal never
+ * reaches this. A caller judges a literal itself, with `isBlockedAddress` and
+ * `isAllowedTarget`, before it opens the socket.
+ */
+export declare function guardedLookup(port: number, options?: GuardedLookupOptions): LookupFunction;
 /**
  * The dispatcher `safeFetch` hands every request to. One per process, so
  * keep-alive survives across calls; its pool holds only connections a `safeFetch`

package/dist/types.d.ts

@@ -72,6 +72,12 @@ export interface IOutputField {
 export interface IOutputPort {
     kind: OutputKind;
     dataType: DataType;
+    /**
+     * The port's name, as a branch and an edge refer to it. Lowercase kebab-case —
+     * `not-found`, never `notFound` — because the registry refuses anything else
+     * on upload and `rvnxx-nodes manifest` stops on it (`SLUG_PATTERN`). A setting's
+     * `key` may be camelCase; a port name may not.
+     */
     name?: string;
     label?: LocalizedString;
     description?: LocalizedString;
@@ -95,6 +101,7 @@ export interface IOutputPort {
      */
     resolveOutputs?: boolean;
     fallback?: {
+        /** Lowercase kebab-case, as {@link IOutputPort.name}. */
         name: string;
         label?: LocalizedString;
         description?: LocalizedString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/integrations-node-sdk",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "description": "TypeScript interfaces and utilities for Revenexx integration nodes",
   "license": "MIT",
   "author": "revenexx GmbH",