@revenexx/integrations-node-sdk 1.11.0 → 1.14.0

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,13 +44,20 @@ __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,
+  VPN_ROUTE_MISSING: () => VPN_ROUTE_MISSING,
+  VPN_UNAVAILABLE: () => VPN_UNAVAILABLE,
+  allowedTargets: () => allowedTargets,
   assertBranchNamed: () => assertBranchNamed,
   assertPublicUrl: () => assertPublicUrl,
   backoffDelay: () => backoffDelay,
@@ -62,14 +70,20 @@ __export(index_exports, {
   extractCredentialManifests: () => extractCredentialManifests,
   extractManifest: () => extractManifest,
   extractManifests: () => extractManifests,
+  guardRelaxedForLocalDev: () => guardRelaxedForLocalDev,
+  guardedLookup: () => guardedLookup,
   headerCrossesOrigin: () => headerCrossesOrigin,
   httpErrorResult: () => httpErrorResult,
+  installAllowedTargets: () => installAllowedTargets,
+  isAllowedTarget: () => isAllowedTarget,
   isBlockedAddress: () => isBlockedAddress,
   isMultiPort: () => isMultiPort,
   isNodeWithIteration: () => isNodeWithIteration,
   isOAuthAuthorizeCredential: () => isOAuthAuthorizeCredential,
   isOperator: () => isOperator,
+  isVpnErrorCode: () => isVpnErrorCode,
   maxBytesConfigField: () => maxBytesConfigField,
+  nodeManifestProblems: () => nodeManifestProblems,
   normalizeCredentialType: () => normalizeCredentialType,
   normalizeLocalized: () => normalizeLocalized,
   outputProblems: () => outputProblems,
@@ -213,6 +227,12 @@ var NodeError = class extends Error {
     this.meta = meta;
   }
 };
+var VPN_UNAVAILABLE = "VPN_UNAVAILABLE";
+var VPN_ROUTE_MISSING = "VPN_ROUTE_MISSING";
+var VPN_ERROR_CODES = Object.freeze([VPN_UNAVAILABLE, VPN_ROUTE_MISSING]);
+function isVpnErrorCode(code) {
+  return VPN_ERROR_CODES.includes(code);
+}
 
 // src/nodeErrors.ts
 function toErrorOutput(err) {
@@ -359,8 +379,123 @@ function assertBranchNamed(node, result, config) {
 
 // src/ssrf.ts
 var import_node_diagnostics_channel = require("diagnostics_channel");
+var import_node_dns = __toESM(require("dns"), 1);
+var import_node_net2 = require("net");
+var import_ipaddr2 = __toESM(require("ipaddr.js"), 1);
+var import_undici = require("undici");
+
+// src/allowedTargets.ts
 var import_node_net = require("net");
 var import_ipaddr = __toESM(require("ipaddr.js"), 1);
+var ALLOWED_TARGETS_SYMBOL = /* @__PURE__ */ Symbol.for("revenexx.ssrf.allowedTargets");
+var EMPTY = Object.freeze([]);
+var V4_ENTRY = /^(\d{1,3}(?:\.\d{1,3}){3}):(\d{1,5})$/;
+var V6_ENTRY = /^\[([0-9A-Fa-f:.]+)\]:(\d{1,5})$/;
+function canonicalAddress(ip) {
+  const bare = ip.startsWith("[") && ip.endsWith("]") ? ip.slice(1, -1) : ip;
+  if ((0, import_node_net.isIP)(bare) === 0) return void 0;
+  try {
+    return import_ipaddr.default.process(bare).toString();
+  } catch {
+    return void 0;
+  }
+}
+function validPort(port) {
+  return Number.isInteger(port) && port >= 1 && port <= 65535;
+}
+var TARGET_RANGES = /* @__PURE__ */ new Set(["private", "uniqueLocal"]);
+function loopbackTargetsAllowed() {
+  const raw = process.env["RVNXX_SSRF_TARGETS_ALLOW_LOOPBACK"];
+  return raw != null && ["1", "true", "yes"].includes(raw.trim().toLowerCase());
+}
+function parseTarget(entry, allowLoopback) {
+  if (typeof entry !== "string") return void 0;
+  const v4 = V4_ENTRY.exec(entry);
+  const m = v4 ?? V6_ENTRY.exec(entry);
+  if (!m) return void 0;
+  const host = m[1];
+  const port = Number(m[2]);
+  if (v4 && !import_ipaddr.default.IPv4.isValidFourPartDecimal(host)) return void 0;
+  if (!validPort(port)) return void 0;
+  const address = canonicalAddress(host);
+  if (address === void 0) return void 0;
+  const range = import_ipaddr.default.parse(address).range();
+  if (!TARGET_RANGES.has(range) && !(allowLoopback && range === "loopback")) return void 0;
+  return `${address}:${port}`;
+}
+var allowListStats = { validations: 0 };
+var keysByList = /* @__PURE__ */ new WeakMap();
+function keysOf(list) {
+  const allowLoopback = loopbackTargetsAllowed();
+  let byMode = keysByList.get(list);
+  if (byMode === void 0) {
+    byMode = /* @__PURE__ */ new Map();
+    keysByList.set(list, byMode);
+  }
+  const cached = byMode.get(allowLoopback);
+  if (cached !== void 0) return cached;
+  allowListStats.validations++;
+  const keys = /* @__PURE__ */ new Set();
+  let result = keys;
+  for (const entry of list) {
+    const key = parseTarget(entry, allowLoopback);
+    if (key === void 0) {
+      result = null;
+      break;
+    }
+    keys.add(key);
+  }
+  byMode.set(allowLoopback, result);
+  return result;
+}
+function installedList(holder) {
+  const descriptor = Object.getOwnPropertyDescriptor(holder, ALLOWED_TARGETS_SYMBOL);
+  if (descriptor === void 0 || !("value" in descriptor)) return null;
+  if (descriptor.writable || descriptor.configurable) return null;
+  const value = descriptor.value;
+  if (!Array.isArray(value) || !Object.isFrozen(value)) return null;
+  const keys = keysOf(value);
+  return keys === null ? null : { list: value, keys };
+}
+function readAllowedTargets(holder) {
+  return installedList(holder)?.list ?? EMPTY;
+}
+function isAllowedTargetOn(holder, ip, port) {
+  const installed = installedList(holder);
+  if (installed === null || !validPort(port)) return false;
+  const address = canonicalAddress(ip);
+  return address !== void 0 && installed.keys.has(`${address}:${port}`);
+}
+function installAllowedTargetsOn(holder, targets) {
+  if (Object.getOwnPropertyDescriptor(holder, ALLOWED_TARGETS_SYMBOL) !== void 0) {
+    throw new Error("The SSRF allow-list is already installed, and is installed once per process");
+  }
+  if (!Array.isArray(targets)) throw new TypeError('The SSRF allow-list must be an array of "<ip>:<port>" strings');
+  for (const entry of targets) {
+    if (parseTarget(entry, loopbackTargetsAllowed()) === void 0) {
+      throw new TypeError(
+        `Not an allowed target: ${JSON.stringify(entry)} (expected "<ip>:<port>" or "[v6]:<port>" at an RFC 1918 or unique-local address)`
+      );
+    }
+  }
+  Object.defineProperty(holder, ALLOWED_TARGETS_SYMBOL, {
+    value: Object.freeze([...targets]),
+    writable: false,
+    configurable: false,
+    enumerable: false
+  });
+}
+function installAllowedTargets(targets) {
+  installAllowedTargetsOn(globalThis, targets);
+}
+function allowedTargets() {
+  return readAllowedTargets(globalThis);
+}
+function isAllowedTarget(ip, port) {
+  return isAllowedTargetOn(globalThis, ip, port);
+}
+
+// src/ssrf.ts
 var ssrfResolver = {
   lookup: async (hostname) => {
     const { lookup } = await import("dns/promises");
@@ -372,15 +507,15 @@ function isIPv6(addr) {
   return addr.kind() === "ipv6";
 }
 var PUBLIC_RANGE = "unicast";
-var GLOBAL_UNICAST_V6 = import_ipaddr.default.parseCIDR("2000::/3");
+var GLOBAL_UNICAST_V6 = import_ipaddr2.default.parseCIDR("2000::/3");
 var V4_EMBEDDING_RANGES = /* @__PURE__ */ new Set(["ipv4Mapped", "rfc6052"]);
 function embeddedIpv4(addr) {
-  return import_ipaddr.default.fromByteArray(addr.toByteArray().slice(12));
+  return import_ipaddr2.default.fromByteArray(addr.toByteArray().slice(12));
 }
 function isBlockedAddress(ip) {
   let addr;
   try {
-    addr = import_ipaddr.default.parse(ip);
+    addr = import_ipaddr2.default.parse(ip);
   } catch {
     return true;
   }
@@ -397,19 +532,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
   });
 }
@@ -466,8 +607,86 @@ function judgeConnection(message) {
   if (guardRelaxedForLocalDev()) return;
   const peer = socket.remoteAddress;
   if (peer != null && !isBlockedAddress(peer)) return;
+  const remotePort = socket.remotePort;
+  if (peer != null && allowedTargets().length > 0 && !Number.isInteger(remotePort)) {
+    reportUnreadablePeerPort();
+    socket.destroy(unreadablePortError(normalizeHost(hostname)));
+    return;
+  }
+  if (peer != null && isAllowedTarget(peer, remotePort)) return;
   socket.destroy(connectBlockedError(normalizeHost(hostname), peer));
 }
+var unreadablePeerPortLogged = false;
+function reportUnreadablePeerPort() {
+  if (unreadablePeerPortLogged) return;
+  unreadablePeerPortLogged = true;
+  console.warn(
+    "[ssrf] a connection reported no remote port: the SSRF allow-list cannot be consulted, so private peers are refused."
+  );
+}
+function unreadablePortError(host) {
+  return new NodeError(
+    "BLOCKED_ADDRESS",
+    `Blocked request to ${host}: the port the connection landed on could not be read, so the allow-list could not be consulted`,
+    { status: 0 }
+  );
+}
+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) {
+        callback(err, "");
+        return;
+      }
+      if (addresses.length === 0) {
+        callback(emptyAnswer(hostname), "");
+        return;
+      }
+      if (!guardRelaxedForLocalDev()) {
+        const host = hostname;
+        for (const a of addresses) {
+          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);
+      else callback(null, addresses[0].address, addresses[0].family);
+    });
+  };
+}
+var connectors = /* @__PURE__ */ new Map();
+function connectorFor(port) {
+  let connector = connectors.get(port);
+  if (connector === void 0) {
+    connector = (0, import_undici.buildConnector)({ lookup: judgingLookup(port) });
+    connectors.set(port, connector);
+  }
+  return connector;
+}
+var dispatcher;
+function guardedDispatcher() {
+  dispatcher ??= new import_undici.Agent({
+    connect: (opts, callback) => {
+      const port = opts.port === "" ? opts.protocol === "https:" ? 443 : 80 : Number(opts.port);
+      return connectorFor(port)(opts, callback);
+    }
+  });
+  return dispatcher;
+}
 function guardConnectionsTo(url) {
   if (!connectGuardInstalled) {
     connectGuardInstalled = true;
@@ -520,8 +739,10 @@ async function assertPublicUrl(url, opts = {}) {
   if (lower === "localhost" || lower.endsWith(".localhost")) {
     throw new NodeError("BLOCKED_ADDRESS", `Blocked loopback host: ${host}`, { status: 0 });
   }
-  if ((0, import_node_net.isIP)(host) !== 0) {
-    if (isBlockedAddress(host)) throw blockedError(host, host);
+  const port = u.port === "" ? u.protocol === "https:" ? 443 : 80 : Number(u.port);
+  const refused = (address) => isBlockedAddress(address) && !isAllowedTarget(address, port);
+  if ((0, import_node_net2.isIP)(host) !== 0) {
+    if (refused(host)) throw blockedError(host, host);
     return;
   }
   const lookup = opts.lookup ?? ssrfResolver.lookup;
@@ -530,7 +751,7 @@ async function assertPublicUrl(url, opts = {}) {
     throw new NodeError("BLOCKED_ADDRESS", `Could not resolve host: ${host}`, { status: 0 });
   }
   for (const a of addresses) {
-    if (isBlockedAddress(a.address)) throw blockedError(host, a.address);
+    if (refused(a.address)) throw blockedError(host, a.address);
   }
 }
 
@@ -625,34 +846,84 @@ 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 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 }
+  );
+  let answer;
+  try {
+    answer = new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
+  } catch {
+    return res;
+  }
+  return withUrl(answer, res.url);
+}
+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;
+}
+async function timedFetch(url, fetchOptions, ctxSignal, deadline) {
   try {
-    return await fetch(url, { ...fetchOptions, signal });
+    return await fetch(url, { ...fetchOptions, signal: deadline.signal, dispatcher: guardedDispatcher() });
   } 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);
+    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) {
@@ -674,16 +945,27 @@ function refuseUserinfo(url, status = 0) {
   }
 }
 async function guardedFetch(url, fetchOptions, ctxSignal, effectiveMs, binding) {
+  const deadline = attemptDeadline(ctxSignal, effectiveMs);
+  try {
+    const res = await followHops(url, fetchOptions, ctxSignal, deadline, effectiveMs, binding);
+    deadline.clear();
+    return answerUnderDeadline(res, ctxSignal, deadline);
+  } catch (err) {
+    deadline.clear();
+    throw err;
+  }
+}
+async function followHops(url, fetchOptions, ctxSignal, deadline, effectiveMs, 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);
     } finally {
       release();
     }
@@ -725,7 +1007,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) {
@@ -873,8 +1155,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,
@@ -997,6 +1279,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,
@@ -1281,6 +1610,7 @@ function base64Url(buf) {
   ApiKeyCredential,
   BaseCredential,
   BasicAuthCredential,
+  CONFIG_KEY_PATTERN,
   DEFAULT_MAX_RESPONSE_BYTES,
   DEFAULT_RETRY_ATTEMPTS,
   DEFAULT_RETRY_DELAY_MS,
@@ -1291,13 +1621,20 @@ 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,
+  VPN_ROUTE_MISSING,
+  VPN_UNAVAILABLE,
+  allowedTargets,
   assertBranchNamed,
   assertPublicUrl,
   backoffDelay,
@@ -1310,14 +1647,20 @@ function base64Url(buf) {
   extractCredentialManifests,
   extractManifest,
   extractManifests,
+  guardRelaxedForLocalDev,
+  guardedLookup,
   headerCrossesOrigin,
   httpErrorResult,
+  installAllowedTargets,
+  isAllowedTarget,
   isBlockedAddress,
   isMultiPort,
   isNodeWithIteration,
   isOAuthAuthorizeCredential,
   isOperator,
+  isVpnErrorCode,
   maxBytesConfigField,
+  nodeManifestProblems,
   normalizeCredentialType,
   normalizeLocalized,
   outputProblems,

package/dist/index.d.ts

@@ -8,8 +8,9 @@ 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';
 export * from './credentials.js';