@zapier/zapier-sdk 0.102.4 → 0.103.0

package/dist/{chunk-WVRZG6I6.cjs → chunk-RHL6GGME.cjs}

@@ -2032,8 +2032,528 @@ function parseDeprecationDate(value) {
   return Number(match[1]) * 1e3;
 }
 
+// src/api/routing/config.ts
+var pathConfig = {
+  // e.g. /relay -> https://sdkapi.zapier.com/api/v0/sdk/relay/...
+  "/relay": {
+    authHeader: "X-Relay-Authorization",
+    pathPrefix: "/api/v0/sdk/relay",
+    omitDeprecationMessaging: true
+  },
+  // The concrete gateway form of the relay route. Callers that pass the
+  // already-prefixed path reach the same third-party upstreams, so it must
+  // classify as relay too; without this entry it would match nothing and
+  // sniff deprecation headers off a relay response.
+  "/api/v0/sdk/relay": {
+    override: { enabled: false },
+    omitDeprecationMessaging: true
+  },
+  // Concrete sdkapi routes that do not live behind /api/v0/sdk/<service>.
+  "/api/v0": {},
+  // e.g. /zapier -> https://sdkapi.zapier.com/api/v0/sdk/zapier/...
+  "/zapier": {
+    authHeader: "Authorization",
+    pathPrefix: "/api/v0/sdk/zapier"
+  },
+  // e.g. /tables -> https://sdkapi.zapier.com/api/v0/sdk/tables/...
+  "/tables": {
+    authHeader: "Authorization",
+    pathPrefix: "/api/v0/sdk/tables"
+  },
+  // e.g. /trigger-inbox -> https://sdkapi.zapier.com/api/v0/sdk/trigger-inbox/...
+  "/trigger-inbox": {
+    authHeader: "Authorization",
+    pathPrefix: "/api/v0/sdk/trigger-inbox"
+  },
+  // e.g. /sdkdurableapi -> https://sdkapi.zapier.com/api/v0/sdk/sdkdurableapi/...
+  // sdkapi proxies to the sdkdurableapi backend.
+  "/sdkdurableapi": {
+    authHeader: "Authorization",
+    pathPrefix: "/api/v0/sdk/sdkdurableapi"
+  },
+  // e.g. /durableworkflowzaps -> https://sdkapi.zapier.com/api/v0/sdk/durableworkflowzaps/...
+  // sdkapi proxies to the durableworkflowzaps backend.
+  "/durableworkflowzaps": {
+    authHeader: "Authorization",
+    pathPrefix: "/api/v0/sdk/durableworkflowzaps"
+  },
+  // e.g. /code-substrate-runner -> https://sdkapi.zapier.com/api/v0/sdk/code-substrate-runner/...
+  // sdkapi proxies to the code-substrate-runner backend.
+  "/code-substrate-runner": {
+    authHeader: "Authorization",
+    pathPrefix: "/api/v0/sdk/code-substrate-runner"
+  },
+  // e.g. /code-substrate-workflows -> https://sdkapi.zapier.com/api/v0/sdk/code-substrate-workflows/...
+  // sdkapi proxies to the code-substrate-workflows backend.
+  "/code-substrate-workflows": {
+    authHeader: "Authorization",
+    pathPrefix: "/api/v0/sdk/code-substrate-workflows"
+  },
+  // e.g. /code-substrate-analyzer/validations ->
+  // https://api.zapier.com/code-substrate-analyzer/v0/validations
+  "/code-substrate-analyzer": {
+    authHeader: "Authorization",
+    pathPrefix: "/code-substrate-analyzer/v0",
+    subdomain: "api",
+    override: { pathPrefixMode: "preserve" }
+  },
+  // e.g. /forms/v0/forms -> https://api.zapier.com/forms/v0/forms
+  // The Forms API is registered on the Public API Gateway and has no sdkapi
+  // proxy route, so it goes straight to the gateway. Its governance metadata
+  // rewrites /forms/v0/... to the backend's /api/forms/v0/..., which is why no
+  // pathPrefix is applied here.
+  "/forms": {
+    authHeader: "Authorization",
+    subdomain: "api"
+  }
+};
+
+// src/api/routing/default.ts
+function resolveDefaultRoute({
+  path,
+  baseUrl
+}) {
+  const matchingPathEntries = findPathConfigEntries({ path });
+  const routingMatch = matchingPathEntries[0];
+  let finalPath = path;
+  if (routingMatch?.config.pathPrefix) {
+    const pathWithoutPrefix = path.slice(routingMatch.configPath.length) || "/";
+    finalPath = `${routingMatch.config.pathPrefix}${pathWithoutPrefix}`;
+  }
+  const zapierBaseUrl = getZapierBaseUrl(baseUrl);
+  if (zapierBaseUrl === baseUrl.replace(/\/$/, "")) {
+    const originalBaseUrl = new URL(baseUrl);
+    const subdomain = routingMatch?.config.subdomain ?? "sdkapi";
+    const finalBaseUrl = `https://${subdomain}.${originalBaseUrl.hostname}`;
+    return buildRouteResult({
+      url: new URL(finalPath, finalBaseUrl),
+      matchingPathEntries,
+      routingMatch
+    });
+  }
+  const parsedBaseUrl = new URL(baseUrl);
+  const basePath = parsedBaseUrl.pathname.replace(/\/$/, "");
+  return buildRouteResult({
+    url: new URL(basePath + finalPath, parsedBaseUrl.origin),
+    matchingPathEntries,
+    routingMatch
+  });
+}
+function buildRouteResult({
+  url,
+  matchingPathEntries,
+  routingMatch
+}) {
+  const resolvedPathEntries = findPathConfigEntries({
+    path: url.pathname,
+    matchResolvedGatewayPath: true
+  });
+  const deprecationPathMatches = [
+    ...matchingPathEntries,
+    ...resolvedPathEntries
+  ];
+  const canSendDeprecationMessaging = deprecationPathMatches.length > 0 && deprecationPathMatches.every(
+    ({ config }) => config.omitDeprecationMessaging !== true
+  );
+  return {
+    url,
+    pathConfig: routingMatch?.config,
+    canSendDeprecationMessaging
+  };
+}
+function findPathConfigEntries({
+  path,
+  matchResolvedGatewayPath = false
+}) {
+  const pathSegments = path.split("/").filter(Boolean);
+  return Object.entries(pathConfig).filter(([configPath, config]) => {
+    if (!matchResolvedGatewayPath) {
+      return path === configPath || path.startsWith(`${configPath}/`);
+    }
+    const prefixSegments = (config.pathPrefix ?? configPath).split("/").filter(Boolean);
+    return pathSegments.some(
+      (_, startIndex) => prefixSegments.every(
+        (segment, offset) => pathSegments[startIndex + offset] === segment
+      )
+    );
+  }).map(([configPath, config]) => ({ configPath, config }));
+}
+
+// src/api/routing/overrides.ts
+var ROUTE_ORIGIN_ENV_PREFIX = "ZAPIER_ROUTE_ORIGIN_";
+function createRoutingConfig({
+  pathConfig: pathConfig2
+}) {
+  const routeByEnvName = new Map(
+    Object.entries(pathConfig2).filter(([, routeConfig]) => isRouteOverrideEnabled({ routeConfig })).map(([route]) => [encodeRouteOriginEnvName({ route }), route])
+  );
+  return { pathConfig: pathConfig2, routeByEnvName };
+}
+function encodeRouteOriginEnvName({ route }) {
+  return `${ROUTE_ORIGIN_ENV_PREFIX}${route.slice(1).split("/").map((segment) => segment.replace(/-/g, "_").toUpperCase()).join("__")}`;
+}
+function createRouteOverrideEntry({
+  route,
+  source,
+  sourceReference,
+  origin
+}) {
+  return {
+    route,
+    source,
+    sourceReference,
+    origin: parseRouteOverrideOrigin({
+      origin,
+      sourceLabel: describeRouteOverrideSource({ source, sourceReference })
+    })
+  };
+}
+function describeRouteOverrideSource({
+  source,
+  sourceReference
+}) {
+  return source === "environment-variable" ? `environment variable ${sourceReference}` : `routeOverrides[${JSON.stringify(sourceReference)}]`;
+}
+function readOptionRouteOverrideEntries({
+  routeOverrides,
+  routingConfig: routingConfig2
+}) {
+  const entries = [];
+  if (!routeOverrides) {
+    return entries;
+  }
+  for (const [route, origin] of Object.entries(routeOverrides)) {
+    assertSupportedRouteOverride({ route, routingConfig: routingConfig2 });
+    entries.push(
+      createRouteOverrideEntry({
+        route,
+        source: "sdk-option",
+        sourceReference: route,
+        origin
+      })
+    );
+  }
+  return entries;
+}
+function buildRouteOverrideMap({
+  environmentEntries,
+  optionEntries
+}) {
+  const routeOverrideMap = /* @__PURE__ */ new Map();
+  for (const entry of environmentEntries) {
+    routeOverrideMap.set(entry.route, entry);
+  }
+  for (const entry of optionEntries) {
+    routeOverrideMap.set(entry.route, entry);
+  }
+  return routeOverrideMap;
+}
+function collectRouteOverrideSources({
+  routingOptions,
+  environment,
+  routingConfig: routingConfig2
+}) {
+  try {
+    const optionEntries = routingOptions?.routeOverrideEntries ?? [];
+    const environmentEntries = readEnvironmentRouteOverrideEntries({
+      environment,
+      routingConfig: routingConfig2
+    });
+    if (optionEntries.length === 0 && environmentEntries.length === 0) {
+      return void 0;
+    }
+    return { optionEntries, environmentEntries };
+  } catch (error) {
+    if (isZapierError(error) && error.code === "ZAPIER_CONFIGURATION_ERROR") {
+      throw error;
+    }
+    return void 0;
+  }
+}
+function findRouteOverrideMatch({
+  path,
+  routeOverrideMap,
+  routingConfig: routingConfig2
+}) {
+  let bestMatch;
+  const { pathname } = splitPathReference({ path });
+  for (const override of routeOverrideMap.values()) {
+    const { route } = override;
+    for (const candidate of getRouteCandidates({
+      route,
+      override,
+      routingConfig: routingConfig2
+    })) {
+      if (!pathnameMatchesPrefix({
+        pathname,
+        prefix: candidate.matchedPrefix
+      })) {
+        continue;
+      }
+      if (!bestMatch || compareRouteOverrideMatches(candidate, bestMatch) < 0) {
+        bestMatch = candidate;
+      }
+    }
+  }
+  return bestMatch;
+}
+function resolveOverrideRoute({
+  overrideMatch,
+  path
+}) {
+  const { matchedPrefix, routeConfig, override } = overrideMatch;
+  const directPath = deriveDirectPath({ path, matchedPrefix, routeConfig });
+  return {
+    url: buildRouteOverrideUrl({ origin: override.origin, path: directPath }),
+    pathConfig: routeConfig,
+    canSendDeprecationMessaging: false
+  };
+}
+function deriveDirectPath({
+  path,
+  matchedPrefix,
+  routeConfig
+}) {
+  const { pathPrefix } = routeConfig;
+  if (!pathPrefix) {
+    return path;
+  }
+  const remainingPath = path.slice(matchedPrefix.length) || "/";
+  const override = routeConfig.override;
+  const pathPrefixMode = override?.enabled === false ? "strip" : override?.pathPrefixMode ?? "strip";
+  return pathPrefixMode === "preserve" ? `${pathPrefix}${remainingPath}` : remainingPath;
+}
+function readEnvironmentRouteOverrideEntries({
+  environment,
+  routingConfig: routingConfig2
+}) {
+  const entries = [];
+  if (!environment) {
+    return entries;
+  }
+  for (const [envName, route] of routingConfig2.routeByEnvName) {
+    let value;
+    try {
+      if (!Object.prototype.hasOwnProperty.call(environment, envName)) {
+        continue;
+      }
+      value = environment[envName];
+    } catch {
+      continue;
+    }
+    if (isUnsetEnvironmentValue(value)) {
+      continue;
+    }
+    entries.push(
+      createRouteOverrideEntry({
+        route,
+        source: "environment-variable",
+        sourceReference: envName,
+        origin: value
+      })
+    );
+  }
+  return entries;
+}
+function isUnsetEnvironmentValue(value) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  return typeof value === "string" && value.trim() === "";
+}
+function assertSupportedRouteOverride({
+  route,
+  routingConfig: routingConfig2
+}) {
+  if (!Object.prototype.hasOwnProperty.call(routingConfig2.pathConfig, route)) {
+    throw new ZapierConfigurationError(
+      `Route override is not supported for ${route}`,
+      { configType: "routeOverrides" }
+    );
+  }
+  const routeConfig = routingConfig2.pathConfig[route];
+  if (!isRouteOverrideEnabled({ routeConfig })) {
+    throw new ZapierConfigurationError(
+      `Route override is disabled for ${route}`,
+      { configType: "routeOverrides" }
+    );
+  }
+}
+function parseRouteOverrideOrigin({
+  origin,
+  sourceLabel
+}) {
+  if (typeof origin !== "string") {
+    throw new ZapierConfigurationError(
+      `Invalid route override origin for ${sourceLabel}`,
+      { configType: "routeOverrides" }
+    );
+  }
+  let url;
+  try {
+    url = new URL(origin);
+  } catch {
+    throw new ZapierConfigurationError(
+      `Invalid route override origin for ${sourceLabel}`,
+      { configType: "routeOverrides" }
+    );
+  }
+  const includesOnlyOrigin = url.username === "" && url.password === "" && url.pathname === "/" && url.search === "" && url.hash === "";
+  if (!includesOnlyOrigin) {
+    throw new ZapierConfigurationError(
+      `Invalid route override origin for ${sourceLabel}`,
+      { configType: "routeOverrides" }
+    );
+  }
+  if (url.protocol === "https:") {
+    return url.origin;
+  }
+  if (url.protocol === "http:" && isLoopbackHost(url.hostname)) {
+    return url.origin;
+  }
+  throw new ZapierConfigurationError(
+    `Invalid route override origin for ${sourceLabel}: expected https, or http on a loopback host`,
+    { configType: "routeOverrides" }
+  );
+}
+function isLoopbackHost(hostname) {
+  return hostname === "localhost" || hostname === "[::1]" || // pii:allow
+  // RFC 6761 reserves .localhost names for loopback.
+  hostname.endsWith(".localhost") || /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(hostname);
+}
+function compareRouteOverrideMatches(a, b) {
+  return b.matchedPrefix.length - a.matchedPrefix.length || Number(b.isExactRouteSpelling) - Number(a.isExactRouteSpelling);
+}
+function getRouteCandidates({
+  route,
+  override,
+  routingConfig: routingConfig2
+}) {
+  const routeConfig = routingConfig2.pathConfig[route];
+  if (!routeConfig || !isRouteOverrideEnabled({ routeConfig })) {
+    return [];
+  }
+  const candidates = [
+    {
+      route,
+      matchedPrefix: route,
+      isExactRouteSpelling: true,
+      routeConfig,
+      override
+    }
+  ];
+  if (routeConfig.pathPrefix && routeConfig.pathPrefix !== route) {
+    candidates.push({
+      route,
+      matchedPrefix: routeConfig.pathPrefix,
+      isExactRouteSpelling: false,
+      routeConfig,
+      override
+    });
+  }
+  return candidates;
+}
+function buildRouteOverrideUrl({
+  origin,
+  path
+}) {
+  const url = new URL(origin);
+  const { pathname, search, hash } = splitPathReference({ path });
+  url.pathname = pathname;
+  url.search = search;
+  url.hash = hash;
+  return url;
+}
+function splitPathReference({ path }) {
+  const hashStart = path.indexOf("#");
+  const pathWithoutHash = hashStart === -1 ? path : path.slice(0, hashStart);
+  const searchStart = pathWithoutHash.indexOf("?");
+  return {
+    pathname: searchStart === -1 ? pathWithoutHash : pathWithoutHash.slice(0, searchStart),
+    search: searchStart === -1 ? "" : pathWithoutHash.slice(searchStart),
+    hash: hashStart === -1 ? "" : path.slice(hashStart)
+  };
+}
+function pathnameMatchesPrefix({
+  pathname,
+  prefix
+}) {
+  return pathname === prefix || pathname.startsWith(`${prefix}/`);
+}
+function isRouteOverrideEnabled({
+  routeConfig
+}) {
+  return routeConfig.override?.enabled !== false;
+}
+
+// src/api/routing/index.ts
+var routingConfig = createRoutingConfig({ pathConfig });
+function parseRoutingOptions({
+  options
+}) {
+  try {
+    return {
+      routeOverrideEntries: readOptionRouteOverrideEntries({
+        routeOverrides: options.routeOverrides,
+        routingConfig
+      })
+    };
+  } catch (error) {
+    if (isZapierError(error) && error.code === "ZAPIER_CONFIGURATION_ERROR") {
+      throw error;
+    }
+    throw new ZapierConfigurationError("Failed to read SDK routing options", {
+      configType: "routeOverrides",
+      cause: error
+    });
+  }
+}
+function resolveRoute({
+  path,
+  baseUrl,
+  routingOptions = { routeOverrideEntries: [] },
+  environment,
+  debugLog
+}) {
+  const overrideSources = collectRouteOverrideSources({
+    routingOptions,
+    environment,
+    routingConfig
+  });
+  if (!overrideSources) {
+    return resolveDefaultRoute({ path, baseUrl });
+  }
+  const routeOverrideMap = buildRouteOverrideMap(overrideSources);
+  const overrideMatch = findRouteOverrideMatch({
+    path,
+    routeOverrideMap,
+    routingConfig
+  });
+  if (overrideMatch) {
+    const resolved = resolveOverrideRoute({ overrideMatch, path });
+    logRouteOverride({ path, resolved, overrideMatch, debugLog });
+    return resolved;
+  }
+  return resolveDefaultRoute({ path, baseUrl });
+}
+function logRouteOverride({
+  path,
+  resolved,
+  overrideMatch,
+  debugLog
+}) {
+  if (!debugLog) {
+    return;
+  }
+  const { route, override } = overrideMatch;
+  const source = describeRouteOverrideSource(override);
+  debugLog(
+    `Route override: ${path} -> ${resolved.url.toString()} (route ${route} via ${source})`
+  );
+}
+
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.102.4" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.103.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -2157,23 +2677,6 @@ function validateSdkPath(path) {
     );
   }
 }
-function findPathConfigEntries({
-  path,
-  matchResolvedGatewayPath = false
-}) {
-  const pathSegments = path.split("/").filter(Boolean);
-  return Object.entries(pathConfig).filter(([configPath, config]) => {
-    if (!matchResolvedGatewayPath) {
-      return path === configPath || path.startsWith(`${configPath}/`);
-    }
-    const prefixSegments = (config.pathPrefix ?? configPath).split("/").filter(Boolean);
-    return pathSegments.some(
-      (_, startIndex) => prefixSegments.every(
-        (segment, offset) => pathSegments[startIndex + offset] === segment
-      )
-    );
-  }).map(([configPath, config]) => ({ configPath, config }));
-}
 function parseRateLimitHeaders(response) {
   const info = {};
   const retryAfter = response.headers.get("retry-after");
@@ -2215,78 +2718,6 @@ function parseRateLimitHeaders(response) {
   }
   return info;
 }
-var pathConfig = {
-  // e.g. /relay -> https://sdkapi.zapier.com/api/v0/sdk/relay/...
-  "/relay": {
-    authHeader: "X-Relay-Authorization",
-    pathPrefix: "/api/v0/sdk/relay",
-    omitDeprecationMessaging: true
-  },
-  // The concrete gateway form of the relay route. Callers that pass the
-  // already-prefixed path reach the same third-party upstreams, so it must
-  // classify as relay too; without this entry it would match nothing and
-  // sniff deprecation headers off a relay response.
-  "/api/v0/sdk/relay": {
-    omitDeprecationMessaging: true
-  },
-  // Concrete sdkapi routes that do not live behind /api/v0/sdk/<service>.
-  "/api/v0": {},
-  // e.g. /zapier -> https://sdkapi.zapier.com/api/v0/sdk/zapier/...
-  "/zapier": {
-    authHeader: "Authorization",
-    pathPrefix: "/api/v0/sdk/zapier"
-  },
-  // e.g. /tables -> https://sdkapi.zapier.com/api/v0/sdk/tables/...
-  "/tables": {
-    authHeader: "Authorization",
-    pathPrefix: "/api/v0/sdk/tables"
-  },
-  // e.g. /trigger-inbox -> https://sdkapi.zapier.com/api/v0/sdk/trigger-inbox/...
-  "/trigger-inbox": {
-    authHeader: "Authorization",
-    pathPrefix: "/api/v0/sdk/trigger-inbox"
-  },
-  // e.g. /sdkdurableapi -> https://sdkapi.zapier.com/api/v0/sdk/sdkdurableapi/...
-  // sdkapi proxies to the sdkdurableapi backend.
-  "/sdkdurableapi": {
-    authHeader: "Authorization",
-    pathPrefix: "/api/v0/sdk/sdkdurableapi"
-  },
-  // e.g. /durableworkflowzaps -> https://sdkapi.zapier.com/api/v0/sdk/durableworkflowzaps/...
-  // sdkapi proxies to the durableworkflowzaps backend.
-  "/durableworkflowzaps": {
-    authHeader: "Authorization",
-    pathPrefix: "/api/v0/sdk/durableworkflowzaps"
-  },
-  // e.g. /code-substrate-runner -> https://sdkapi.zapier.com/api/v0/sdk/code-substrate-runner/...
-  // sdkapi proxies to the code-substrate-runner backend.
-  "/code-substrate-runner": {
-    authHeader: "Authorization",
-    pathPrefix: "/api/v0/sdk/code-substrate-runner"
-  },
-  // e.g. /code-substrate-workflows -> https://sdkapi.zapier.com/api/v0/sdk/code-substrate-workflows/...
-  // sdkapi proxies to the code-substrate-workflows backend.
-  "/code-substrate-workflows": {
-    authHeader: "Authorization",
-    pathPrefix: "/api/v0/sdk/code-substrate-workflows"
-  },
-  // e.g. /code-substrate-analyzer/validations ->
-  // https://api.zapier.com/code-substrate-analyzer/v0/validations
-  "/code-substrate-analyzer": {
-    authHeader: "Authorization",
-    pathPrefix: "/code-substrate-analyzer/v0",
-    subdomain: "api"
-  },
-  // e.g. /forms/v0/forms -> https://api.zapier.com/forms/v0/forms
-  // The Forms API is registered on the Public API Gateway and has no sdkapi
-  // proxy route, so it goes straight to the gateway. Its governance metadata
-  // rewrites /forms/v0/... to the backend's /api/forms/v0/..., which is why no
-  // pathPrefix is applied here.
-  "/forms": {
-    authHeader: "Authorization",
-    subdomain: "api"
-  }
-};
 var ZapierApiClient = class {
   constructor(options) {
     this.options = options;
@@ -2831,43 +3262,13 @@ var ZapierApiClient = class {
   }
   // Apply any special routing logic for configured paths.
   applyPathConfiguration(path) {
-    const matchingPathEntries = findPathConfigEntries({ path });
-    const routingMatch = matchingPathEntries[0];
-    const buildResult = (url2) => {
-      const resolvedPathEntries = findPathConfigEntries({
-        path: url2.pathname,
-        matchResolvedGatewayPath: true
-      });
-      const deprecationPathMatches = [
-        ...matchingPathEntries,
-        ...resolvedPathEntries
-      ];
-      const canSendDeprecationMessaging = deprecationPathMatches.length > 0 && deprecationPathMatches.every(
-        ({ config }) => config.omitDeprecationMessaging !== true
-      );
-      return {
-        url: url2,
-        pathConfig: routingMatch?.config,
-        canSendDeprecationMessaging
-      };
-    };
-    let finalPath = path;
-    if (routingMatch?.config.pathPrefix) {
-      const pathWithoutPrefix = path.slice(routingMatch.configPath.length) || "/";
-      finalPath = `${routingMatch.config.pathPrefix}${pathWithoutPrefix}`;
-    }
-    const zapierBaseUrl = getZapierBaseUrl(this.options.baseUrl);
-    if (zapierBaseUrl === this.options.baseUrl.replace(/\/$/, "")) {
-      const originalBaseUrl = new URL(this.options.baseUrl);
-      const subdomain = routingMatch?.config.subdomain ?? "sdkapi";
-      const finalBaseUrl = `https://${subdomain}.${originalBaseUrl.hostname}`;
-      const url2 = new URL(finalPath, finalBaseUrl);
-      return buildResult(url2);
-    }
-    const baseUrl = new URL(this.options.baseUrl);
-    const basePath = baseUrl.pathname.replace(/\/$/, "");
-    const url = new URL(basePath + finalPath, baseUrl.origin);
-    return buildResult(url);
+    return resolveRoute({
+      path,
+      baseUrl: this.options.baseUrl,
+      routingOptions: this.options.routingOptions,
+      environment: globalThis.process?.env,
+      debugLog: this.options.debugLog
+    });
   }
   // Helper to build full URLs and return routing info
   buildUrl(path, searchParams) {
@@ -3396,6 +3797,7 @@ var ZapierApiClient = class {
 };
 var createZapierApi = (options) => {
   const { debug = false, fetch: originalFetch = globalThis.fetch } = options;
+  const routingOptions = parseRoutingOptions({ options });
   const debugLog = createDebugLogger(debug);
   const debugFetch = createDebugFetch({ originalFetch, debugLog });
   return new ZapierApiClient({
@@ -3406,7 +3808,9 @@ var createZapierApi = (options) => {
     fetch: debugFetch,
     // Built from the caller's own `fetch`, not `debugFetch`: the pipeline wraps
     // for debug itself, and passing the wrapped one would log twice.
-    sendHttpRequest: options.sendHttpRequest ?? createZapierSendHttpRequest({ fetch: options.fetch, debug })
+    sendHttpRequest: options.sendHttpRequest ?? createZapierSendHttpRequest({ fetch: options.fetch, debug }),
+    debugLog,
+    routingOptions
   });
 };
 
@@ -3495,7 +3899,8 @@ var apiPlugin = kitcore.defineProperty({
       maxApprovalRetries,
       approvalMode,
       openAutoModeApprovalsInBrowser,
-      callerPackage
+      callerPackage,
+      routeOverrides
     } = imports.sdkOptions ?? {};
     return createZapierApi({
       baseUrl,
@@ -3512,6 +3917,7 @@ var apiPlugin = kitcore.defineProperty({
       approvalMode,
       openAutoModeApprovalsInBrowser,
       callerPackage,
+      routeOverrides,
       // Inject the graph-composed transport so host `dispatchHttpRequest` wraps
       // apply.
       sendHttpRequest: imports.sendHttpRequest
@@ -11906,6 +12312,7 @@ var BaseSdkOptionsSchema = zod.z.object({
   ),
   debug: zod.z.boolean().optional().describe("Enable debug logging."),
   baseUrl: zod.z.string().optional().describe("Base URL for Zapier API endpoints.").meta({ valueHint: "url" }),
+  routeOverrides: zod.z.record(zod.z.string(), zod.z.string()).optional().describe("Maps SDK route prefixes to direct origins.").meta({ internal: true }),
   trackingBaseUrl: zod.z.string().optional().describe("Base URL for Zapier tracking endpoints.").meta({ valueHint: "url" }),
   /**
    * Maximum number of retries for rate-limited requests (429 responses).