@zapier/zapier-sdk 0.102.4 → 0.104.0

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

@@ -706,7 +706,6 @@ function createDebugFetch(options) {
 // src/utils/retry-utils.ts
 var MAX_CONSECUTIVE_ERRORS = 3;
 var BASE_ERROR_BACKOFF_MILLISECONDS = 1e3;
-var BASE_EXPONENTIAL_BACKOFF_MILLISECONDS = 1e3;
 var JITTER_FACTOR = 0.5;
 function calculateErrorBackoffMs(baseInterval, errorCount) {
   const jitter = Math.random() * JITTER_FACTOR * baseInterval;
@@ -717,11 +716,6 @@ function calculateErrorBackoffMs(baseInterval, errorCount) {
   );
   return Math.floor(baseInterval + jitter + errorBackoff);
 }
-function calculateExponentialBackoffMs(attempt, baseDelayMs = BASE_EXPONENTIAL_BACKOFF_MILLISECONDS) {
-  const baseDelay = baseDelayMs * Math.pow(2, attempt - 1);
-  const jitter = Math.random() * JITTER_FACTOR * baseDelay;
-  return Math.floor(baseDelay + jitter);
-}
 function sleep(ms, signal) {
   if (!signal) {
     return new Promise((resolve2) => setTimeout(resolve2, ms));
@@ -1076,7 +1070,114 @@ var sdkOptionsPluginRef = kitcore.declareOptionalProperty({
   id: SDK_OPTIONS_ID
 });
 
+// src/api/rate-limit.ts
+var EPOCH_THRESHOLD_SECONDS = 1e9;
+function parseRateLimitHeaders(response) {
+  const info = {};
+  const retryAfter = response.headers.get("retry-after");
+  if (retryAfter) {
+    const seconds = parseInt(retryAfter, 10);
+    if (!isNaN(seconds)) {
+      info.retryAfterMs = Math.max(0, seconds * 1e3);
+    } else {
+      const date = Date.parse(retryAfter);
+      if (!isNaN(date)) {
+        info.retryAfterMs = Math.max(0, date - Date.now());
+      }
+    }
+  }
+  const reset = response.headers.get("x-ratelimit-reset");
+  if (reset) {
+    const resetValue = parseInt(reset, 10);
+    if (!isNaN(resetValue)) {
+      const isEpoch = resetValue >= EPOCH_THRESHOLD_SECONDS;
+      info.resetMs = isEpoch ? resetValue * 1e3 : Date.now() + resetValue * 1e3;
+      if (info.retryAfterMs === void 0) {
+        info.retryAfterMs = isEpoch ? Math.max(0, info.resetMs - Date.now()) : Math.max(0, resetValue * 1e3);
+      }
+    }
+  }
+  const limit = response.headers.get("x-ratelimit-limit");
+  if (limit) {
+    const limitNum = parseInt(limit, 10);
+    if (!isNaN(limitNum)) {
+      info.limit = limitNum;
+    }
+  }
+  const remaining = response.headers.get("x-ratelimit-remaining");
+  if (remaining) {
+    const remainingNum = parseInt(remaining, 10);
+    if (!isNaN(remainingNum)) {
+      info.remaining = remainingNum;
+    }
+  }
+  return info;
+}
+
+// src/utils/type-guard-utils.ts
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+}
+
+// src/plugins/transport/retry-events.ts
+var retryCounts = /* @__PURE__ */ new WeakMap();
+function retriesFor(request) {
+  return retryCounts.get(request) ?? 0;
+}
+function createRetryObserver({
+  onEvent,
+  maxNetworkRetries
+}) {
+  return ({ request, attemptNumber, delayMilliseconds, response }) => {
+    retryCounts.set(request, attemptNumber);
+    if (!onEvent || response?.status !== 429) return;
+    const observed = onEvent({
+      type: "api:rate_limit_retry",
+      payload: {
+        retry: attemptNumber,
+        maxNetworkRetries,
+        delayMs: delayMilliseconds,
+        path: request.url,
+        method: request.method ?? "GET",
+        rateLimit: parseRateLimitHeaders(response)
+      },
+      timestamp: Date.now()
+    });
+    if (isPromiseLike(observed)) {
+      void Promise.resolve(observed).catch(() => {
+      });
+    }
+  };
+}
+
 // src/plugins/transport/options.ts
+var RETRYABLE_STATUSES = [429, 500, 502, 503, 504];
+var NON_IDEMPOTENT_RETRYABLE_STATUSES = [429];
+function resolveRetryHttpRequestOptions({
+  maxNetworkRetries,
+  maxNetworkRetryDelayMilliseconds,
+  onEvent
+}) {
+  const retries = maxNetworkRetries ?? ZAPIER_MAX_NETWORK_RETRIES;
+  return {
+    maxAttempts: retries + 1,
+    maxDelayMilliseconds: maxNetworkRetryDelayMilliseconds ?? ZAPIER_MAX_NETWORK_RETRY_DELAY_MILLISECONDS,
+    retryStatuses: RETRYABLE_STATUSES,
+    nonIdempotentRetryStatuses: NON_IDEMPOTENT_RETRYABLE_STATUSES,
+    onRetry: createRetryObserver({ onEvent, maxNetworkRetries: retries })
+  };
+}
+function resolveNetworkRetryDelayMilliseconds({
+  maxNetworkRetryDelaySeconds,
+  maxNetworkRetryDelayMs
+}) {
+  return maxNetworkRetryDelaySeconds != null ? maxNetworkRetryDelaySeconds * 1e3 : maxNetworkRetryDelayMs;
+}
 function resolveTransportFetch({
   fetch: customFetch,
   debug = false
@@ -1104,15 +1205,29 @@ var httpFetchPlugin = kitcore.defineProperty({
 // src/plugins/transport/standalone.ts
 function createZapierSendHttpRequest({
   fetch: customFetch,
-  debug
+  debug,
+  maxNetworkRetries,
+  maxNetworkRetryDelayMilliseconds,
+  onEvent
 }) {
   const sdk = kitcore.createSdk(
     kitcore.definePlugin({
       name: "zapierStandaloneHttpTransport",
-      imports: [kitcore.sendHttpRequestPlugin, httpFetchPlugin],
+      imports: [kitcore.sendHttpRequestPlugin, kitcore.retryHttpRequestPlugin, httpFetchPlugin],
       exports: [kitcore.sendHttpRequestPlugin]
     }),
-    { configuration: { [SDK_OPTIONS_ID]: { fetch: customFetch, debug } } }
+    {
+      configuration: {
+        [SDK_OPTIONS_ID]: { fetch: customFetch, debug },
+        // Filled by configuration rather than the graph's property plugin: the
+        // caller here holds client-shaped ms options, not SDK options.
+        [kitcore.RETRY_HTTP_REQUEST_OPTIONS_ID]: resolveRetryHttpRequestOptions({
+          maxNetworkRetries,
+          maxNetworkRetryDelayMilliseconds,
+          onEvent
+        })
+      }
+    }
   );
   return sdk.sendHttpRequest;
 }
@@ -1770,13 +1885,6 @@ async function invalidateCredentialsToken(options) {
     });
   }
 }
-
-// src/utils/type-guard-utils.ts
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
 var callerContext = kitcore.createAsyncContext();
 function runWithCallerContext(context, fn) {
   let parent;
@@ -2022,9 +2130,6 @@ function sniffDeprecationNotice({
     }
   }
 }
-function isPromiseLike(value) {
-  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
-}
 function parseDeprecationDate(value) {
   if (!value) return void 0;
   const match = /^@(-?\d+)$/.exec(value.trim());
@@ -2032,8 +2137,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.104.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -2149,7 +2774,6 @@ var PollApprovalResponseSchema = zod.z.object({
   approval_url: zod.z.string().optional()
 });
 var APPROVAL_MAX_POLLING_INTERVAL_MILLISECONDS = 5e3;
-var EPOCH_THRESHOLD_SECONDS = 1e9;
 function validateSdkPath(path) {
   if (!path.startsWith("/") || path.startsWith("//")) {
     throw new ZapierValidationError(
@@ -2157,146 +2781,17 @@ 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");
-  if (retryAfter) {
-    const seconds = parseInt(retryAfter, 10);
-    if (!isNaN(seconds)) {
-      info.retryAfterMs = seconds * 1e3;
-    } else {
-      const date = Date.parse(retryAfter);
-      if (!isNaN(date)) {
-        info.retryAfterMs = Math.max(0, date - Date.now());
-      }
-    }
-  }
-  const reset = response.headers.get("x-ratelimit-reset");
-  if (reset) {
-    const resetValue = parseInt(reset, 10);
-    if (!isNaN(resetValue)) {
-      const isEpoch = resetValue >= EPOCH_THRESHOLD_SECONDS;
-      info.resetMs = isEpoch ? resetValue * 1e3 : Date.now() + resetValue * 1e3;
-      if (info.retryAfterMs === void 0) {
-        info.retryAfterMs = isEpoch ? Math.max(0, info.resetMs - Date.now()) : Math.max(0, resetValue * 1e3);
-      }
-    }
-  }
-  const limit = response.headers.get("x-ratelimit-limit");
-  if (limit) {
-    const limitNum = parseInt(limit, 10);
-    if (!isNaN(limitNum)) {
-      info.limit = limitNum;
-    }
-  }
-  const remaining = response.headers.get("x-ratelimit-remaining");
-  if (remaining) {
-    const remainingNum = parseInt(remaining, 10);
-    if (!isNaN(remainingNum)) {
-      info.remaining = remainingNum;
-    }
-  }
-  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;
     /**
      * Perform a request against an already-resolved URL.
      *
-     * Does auth, header merging, and 429 retry — all the cross-cutting
-     * concerns that every Zapier-bound HTTP call needs. Callers that have a
-     * path (e.g. `/relay/...`) should use `rawFetch` instead, which does
-     * path → URL resolution and delegates here.
+     * Does auth and header merging, and converts a terminal 429 into
+     * `ZapierRateLimitError` — the cross-cutting concerns that every
+     * Zapier-bound HTTP call needs and that the transport does not own. Callers
+     * that have a path (e.g. `/relay/...`) should use `rawFetch` instead, which
+     * does path → URL resolution and delegates here.
      *
      * Exposed as a separate helper so call sites with a server-supplied
      * absolute URL (e.g. an approval poll URL) can still share the same
@@ -2330,47 +2825,30 @@ var ZapierApiClient = class {
         resource: _resource,
         ...wireInit
       } = fetchInit;
-      let retries = 0;
-      while (true) {
-        const response = await this.options.sendHttpRequest({
-          ...wireInit,
-          // Set the resolved URL and merged headers after the spread so caller
-          // values cannot override them.
-          url,
-          headers: Object.fromEntries(mergedHeaders)
-        });
-        if (response.status !== 429) {
-          return response;
-        }
-        const rateLimitInfo = parseRateLimitHeaders(response);
-        const delayMs = rateLimitInfo.retryAfterMs ?? calculateExponentialBackoffMs(retries + 1);
-        if (delayMs > this.maxNetworkRetryDelayMilliseconds || retries >= this.maxNetworkRetries) {
-          throw new ZapierRateLimitError(
-            await this.readRateLimitErrorMessage(response),
-            {
-              statusCode: 429,
-              rateLimit: rateLimitInfo,
-              retries
-            }
-          );
-        }
-        retries++;
-        this.emitEvent("api:rate_limit_retry", {
-          retry: retries,
-          maxNetworkRetries: this.maxNetworkRetries,
-          delayMs,
-          path: url,
-          method: init?.method ?? "GET",
-          rateLimit: rateLimitInfo
-        });
-        await sleep(delayMs, init?.signal ?? void 0);
+      const request = {
+        ...wireInit,
+        url,
+        headers: Object.fromEntries(mergedHeaders)
+      };
+      const response = await this.options.sendHttpRequest(request);
+      if (response.status !== 429) {
+        return response;
       }
+      throw new ZapierRateLimitError(
+        await this.readRateLimitErrorMessage(response),
+        {
+          statusCode: 429,
+          rateLimit: parseRateLimitHeaders(response),
+          retries: retriesFor(request)
+        }
+      );
     };
     /**
      * Wrap an outbound HTTP call with the concurrency semaphore. Used by both
      * `rawFetch` (path-based) and the approval-poll path (absolute URL); each
-     * caller acquires per-attempt, so 429 retry sleep is held but the gap
-     * between approval polls and the human-approval wait are not.
+     * caller acquires per request, so the transport's retry sleeps are held
+     * inside the permit but the gap between approval polls and the
+     * human-approval wait are not.
      *
      * The release is registered in a finally that wraps the entire post-
      * acquire flow — including the `wait_end` event emission — so a throwing
@@ -2620,8 +3098,6 @@ var ZapierApiClient = class {
         signal: options.signal
       });
     };
-    this.maxNetworkRetries = options.maxNetworkRetries ?? ZAPIER_MAX_NETWORK_RETRIES;
-    this.maxNetworkRetryDelayMilliseconds = options.maxNetworkRetryDelayMilliseconds ?? options.maxNetworkRetryDelayMs ?? ZAPIER_MAX_NETWORK_RETRY_DELAY_MILLISECONDS;
     const requested = options.maxConcurrentRequests;
     const limit = requested === void 0 || Number.isNaN(requested) ? ZAPIER_MAX_CONCURRENT_REQUESTS : requested;
     if (limit !== Infinity && (!Number.isInteger(limit) || limit < 1 || limit > MAX_CONCURRENCY_LIMIT)) {
@@ -2831,43 +3307,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 +3842,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 +3853,15 @@ 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,
+      onEvent: options.onEvent,
+      maxNetworkRetries: options.maxNetworkRetries,
+      maxNetworkRetryDelayMilliseconds: options.maxNetworkRetryDelayMilliseconds ?? options.maxNetworkRetryDelayMs
+    }),
+    debugLog,
+    routingOptions
   });
 };
 
@@ -3443,10 +3898,30 @@ function getOrCreateApiClient(config) {
     callerPackage
   });
 }
+var retryHttpRequestOptionsPlugin = kitcore.defineProperty({
+  namespace: "kitcore",
+  name: "retryHttpRequestOptions",
+  imports: [sdkOptionsPluginRef],
+  setup: ({ imports }) => resolveRetryHttpRequestOptions({
+    maxNetworkRetries: imports.sdkOptions?.maxNetworkRetries,
+    maxNetworkRetryDelayMilliseconds: resolveNetworkRetryDelayMilliseconds(
+      imports.sdkOptions ?? {}
+    ),
+    onEvent: imports.sdkOptions?.onEvent
+  }),
+  get: ({ state }) => state
+});
+
+// src/plugins/transport/index.ts
 var zapierHttpTransportPlugin = kitcore.definePlugin({
   namespace: "zapier",
   name: "httpTransport",
-  imports: [kitcore.sendHttpRequestPlugin, httpFetchPlugin],
+  imports: [
+    kitcore.sendHttpRequestPlugin,
+    kitcore.retryHttpRequestPlugin,
+    retryHttpRequestOptionsPlugin,
+    httpFetchPlugin
+  ],
   exports: [kitcore.sendHttpRequestPlugin]
 });
 
@@ -3495,7 +3970,8 @@ var apiPlugin = kitcore.defineProperty({
       maxApprovalRetries,
       approvalMode,
       openAutoModeApprovalsInBrowser,
-      callerPackage
+      callerPackage,
+      routeOverrides
     } = imports.sdkOptions ?? {};
     return createZapierApi({
       baseUrl,
@@ -3505,13 +3981,17 @@ var apiPlugin = kitcore.defineProperty({
       fetch: customFetch,
       onEvent,
       maxNetworkRetries,
-      maxNetworkRetryDelayMilliseconds: (maxNetworkRetryDelaySeconds != null ? maxNetworkRetryDelaySeconds * 1e3 : maxNetworkRetryDelayMs) ?? ZAPIER_MAX_NETWORK_RETRY_DELAY_MILLISECONDS,
+      maxNetworkRetryDelayMilliseconds: resolveNetworkRetryDelayMilliseconds({
+        maxNetworkRetryDelaySeconds,
+        maxNetworkRetryDelayMs
+      }) ?? ZAPIER_MAX_NETWORK_RETRY_DELAY_MILLISECONDS,
       maxConcurrentRequests,
       approvalTimeoutMilliseconds: approvalTimeoutSeconds != null ? approvalTimeoutSeconds * 1e3 : approvalTimeoutMs,
       maxApprovalRetries,
       approvalMode,
       openAutoModeApprovalsInBrowser,
       callerPackage,
+      routeOverrides,
       // Inject the graph-composed transport so host `dispatchHttpRequest` wraps
       // apply.
       sendHttpRequest: imports.sendHttpRequest
@@ -11906,19 +12386,23 @@ 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).
+   * Maximum number of retries for rate-limited requests (429 responses) and,
+   * on idempotent methods, retryable server errors (500, 502, 503, 504).
    * Set to 0 to disable retries. Default is 3.
    */
-  maxNetworkRetries: zod.z.number().optional().describe("Max retries for rate-limited requests (default: 3).").meta({ valueHint: "count" }),
+  maxNetworkRetries: zod.z.number().optional().describe(
+    "Max retries for rate-limited and server-error responses (default: 3)."
+  ).meta({ valueHint: "count" }),
   /**
-   * Maximum delay in seconds to wait for a rate-limit retry.
+   * Maximum delay in seconds to wait between network retries.
    * If the server requests a longer delay, the request fails immediately.
    * Default is 60 (60 seconds).
    */
   maxNetworkRetryDelaySeconds: zod.z.number().optional().describe(
-    "Max delay in seconds to wait for a rate-limit retry (default: 60)."
+    "Max delay in seconds to wait between network retries (default: 60)."
   ).meta({ valueHint: "seconds" }),
   /** @deprecated Use `maxNetworkRetryDelaySeconds` instead. */
   maxNetworkRetryDelayMs: zod.z.number().optional().describe("Max delay in ms to wait for retry (default: 60000).").meta({ valueHint: "ms", deprecated: true }),