@zapier/zapier-sdk 0.95.0 → 0.96.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @zapier/zapier-sdk
 
+## 0.96.0
+
+### Minor Changes
+
+- 2726599: Added `createForm` (experimental) to create Zapier Forms from a title, optional description, and typed field list. Forms publish by default and return a shareable `hosted_url`; pass `draft: true` to save without publishing. A complete `document` can be supplied for layouts the field list cannot express.
+
 ## 0.95.0
 
 ### Minor Changes

package/README.md

@@ -63,6 +63,8 @@
   - [`waitForNewConnection`](#waitfornewconnection)
 - [HTTP Requests](#http-requests)
   - [`fetch`](#fetch)
+- [Human Inputs (Experimental)](#human-inputs-experimental)
+  - [`createForm`](#createform--experimental)
 - [Tables](#tables)
   - [`createTable`](#createtable)
   - [`createTableFields`](#createtablefields)
@@ -2592,6 +2594,84 @@ Make authenticated HTTP requests to any API through Zapier. Pass a connectionId
 const result = await zapier.fetch("https://example.com", {});
 ```
 
+### Human Inputs (Experimental)
+
+> ℹ️ **Experimental.** Import from `"@zapier/zapier-sdk/experimental"` to use these methods. Methods and behavior may change.
+
+#### `createForm` 🧪 _experimental_
+
+Create a Zapier Form from a title and optional fields. Forms publish by default and return a shareable `hosted_url`; set `draft` to save without publishing.
+
+**Parameters:**
+
+| Name                      | Type       | Required | Default | Possible Values                                                                                                                                   | Description                                                                                                                                                                                                                                                                                                                     |
+| ------------------------- | ---------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `options`                 | `object`   | ✅       | —       | —                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                 |
+| ​ ↳ `title`               | `string`   | ✅       | —       | —                                                                                                                                                 | The title shown in the Forms UI and on the form.                                                                                                                                                                                                                                                                                |
+| ​ ↳ `description`         | `string`   | ❌       | —       | —                                                                                                                                                 | An optional description of the form.                                                                                                                                                                                                                                                                                            |
+| ​ ↳ `fields[]`            | `object[]` | ❌       | —       | —                                                                                                                                                 | Initial fields to add to the form.                                                                                                                                                                                                                                                                                              |
+| ​   ↳ `label`             | `string`   | ✅       | —       | —                                                                                                                                                 | Human-readable label shown above the input.                                                                                                                                                                                                                                                                                     |
+| ​   ↳ `type`              | `string`   | ✅       | —       | `short_text`, `long_text`, `email`, `number`, `yes_no`, `url`, `date`, `date_range`, `currency`, `phone_number`, `dropdown`, `integration_backed` | The type of field.                                                                                                                                                                                                                                                                                                              |
+| ​   ↳ `required`          | `boolean`  | ❌       | —       | —                                                                                                                                                 | Whether the field must be answered before the form can submit.                                                                                                                                                                                                                                                                  |
+| ​   ↳ `disabled`          | `boolean`  | ❌       | —       | —                                                                                                                                                 | When true, the field is rendered read-only — shown but not editable. A rendering hint only; it is not enforced during submission validation.                                                                                                                                                                                    |
+| ​   ↳ `variant`           | `string`   | ❌       | —       | `checkbox`, `radio`                                                                                                                               | For `yes_no` fields: `checkbox` renders a single toggle, `radio` renders explicit yes/no buttons. Defaults to `checkbox`.                                                                                                                                                                                                       |
+| ​   ↳ `multiUrl`          | `boolean`  | ❌       | —       | —                                                                                                                                                 | For `url` fields: when true the field accepts a list of URLs, otherwise a single URL. Defaults to false.                                                                                                                                                                                                                        |
+| ​   ↳ `includeTime`       | `boolean`  | ❌       | —       | —                                                                                                                                                 | For `date` and `date_range` fields: when true the picker also captures a time. Defaults to false.                                                                                                                                                                                                                               |
+| ​   ↳ `currencyFormat`    | `string`   | ❌       | —       | —                                                                                                                                                 | For `currency` fields: ISO 4217 currency code (e.g. `usd`, `eur`). Controls the symbol shown in the form UI.                                                                                                                                                                                                                    |
+| ​   ↳ `decimals`          | `literal`  | ❌       | —       | —                                                                                                                                                 | For `currency` fields: allowed decimal places. `0` for whole numbers, `2` for up to two decimal places. Defaults to `2`.                                                                                                                                                                                                        |
+| ​   ↳ `defaultCountry`    | `string`   | ❌       | —       | —                                                                                                                                                 | For `phone_number` fields: ISO 3166-1 alpha-2 code for the default selected country (e.g. `US`). Defaults to `US`.                                                                                                                                                                                                              |
+| ​   ↳ `phoneNumberFormat` | `string`   | ❌       | —       | `national`, `international`                                                                                                                       | For `phone_number` fields: `national` omits the country-code prefix, `international` includes it. Defaults to `national`.                                                                                                                                                                                                       |
+| ​   ↳ `acceptedCountries` | `array`    | ❌       | —       | —                                                                                                                                                 | For `phone_number` fields: restrict input to specific ISO 3166-1 alpha-2 country codes. Omit to allow all countries.                                                                                                                                                                                                            |
+| ​   ↳ `options[]`         | `object[]` | ❌       | —       | —                                                                                                                                                 | For `dropdown` fields: the selectable options. At least one is required.                                                                                                                                                                                                                                                        |
+| ​     ↳ `value`           | `string`   | ✅       | —       | —                                                                                                                                                 | The value submitted when this option is selected.                                                                                                                                                                                                                                                                               |
+| ​     ↳ `label`           | `string`   | ✅       | —       | —                                                                                                                                                 | Human-readable label shown to the user.                                                                                                                                                                                                                                                                                         |
+| ​   ↳ `multiSelect`       | `boolean`  | ❌       | —       | —                                                                                                                                                 | For `dropdown` fields: when true the user may select multiple options. Defaults to false.                                                                                                                                                                                                                                       |
+| ​   ↳ `dataSource`        | `object`   | ❌       | —       | —                                                                                                                                                 | For `integration_backed` fields: where to fetch the field's options from at render time.                                                                                                                                                                                                                                        |
+| ​     ↳ `app`             | `string`   | ✅       | —       | —                                                                                                                                                 | Zapier app to pull options from. See `listApps` for the catalog.                                                                                                                                                                                                                                                                |
+| ​     ↳ `actionType`      | `string`   | ✅       | —       | `read`, `read_bulk`                                                                                                                               | Whether the data source returns a single record (`read`) or a collection (`read_bulk`).                                                                                                                                                                                                                                         |
+| ​     ↳ `resource`        | `string`   | ✅       | —       | —                                                                                                                                                 | Resource name within the app — typically a trigger or search key from the app's definition.                                                                                                                                                                                                                                     |
+| ​     ↳ `valueKey`        | `string`   | ❌       | —       | —                                                                                                                                                 | Property on each returned record to use as the submitted option value. Defaults to `id`.                                                                                                                                                                                                                                        |
+| ​     ↳ `labelKey`        | `string`   | ❌       | —       | —                                                                                                                                                 | Property on each returned record to use as the displayed option label. Defaults to a sensible name field.                                                                                                                                                                                                                       |
+| ​ ↳ `draft`               | `boolean`  | ❌       | —       | —                                                                                                                                                 | When true, save without publishing. Omit to publish immediately, making `hosted_url` live.                                                                                                                                                                                                                                      |
+| ​ ↳ `confirmationTitle`   | `string`   | ❌       | —       | —                                                                                                                                                 | Heading shown to the respondent after they submit. Omit to use the form renderer's default.                                                                                                                                                                                                                                     |
+| ​ ↳ `confirmationMessage` | `string`   | ❌       | —       | —                                                                                                                                                 | Message shown to the respondent after they submit, below the confirmation title. Omit to use the form renderer's default.                                                                                                                                                                                                       |
+| ​ ↳ `callbackUrl`         | `string`   | ❌       | —       | —                                                                                                                                                 | Absolute http/https URL notified with the submission JSON each time the form is answered.                                                                                                                                                                                                                                       |
+| ​ ↳ `consumerAuth`        | `string`   | ❌       | —       | `none`, `zapier`                                                                                                                                  | Who may open the published form. `none` (the default) leaves it public to anyone with the link; `zapier` requires the visitor to be signed in to Zapier on the form's owning account.                                                                                                                                           |
+| ​ ↳ `document`            | `object`   | ❌       | —       | —                                                                                                                                                 | Escape hatch: a complete form document tree, sent as-is. When supplied it replaces the document built from `fields`, and `title`, `description`, `confirmationTitle`, and `confirmationMessage` are ignored. Use only for structures the flat field list cannot express, such as approval decisions or multi-column row layout. |
+| ​   ↳ `id`                | `string`   | ✅       | —       | —                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                 |
+| ​   ↳ `type`              | `string`   | ✅       | —       | `root`                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                 |
+| ​   ↳ `attrs`             | `object`   | ✅       | —       | —                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                 |
+| ​     ↳ `schema_version`  | `number`   | ✅       | —       | —                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                 |
+| ​     ↳ `title`           | `string`   | ✅       | —       | —                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                 |
+| ​   ↳ `children`          | `array`    | ❌       | —       | —                                                                                                                                                 |                                                                                                                                                                                                                                                                                                                                 |
+
+**Returns:** `Promise<FormItem>`
+
+| Name                    | Type      | Required | Possible Values | Description |
+| ----------------------- | --------- | -------- | --------------- | ----------- |
+| `data`                  | `object`  | ✅       | —               |             |
+| ​ ↳ `id`                | `string`  | ✅       | —               |             |
+| ​ ↳ `title`             | `string`  | ✅       | —               |             |
+| ​ ↳ `description`       | `string`  | ❌       | —               |             |
+| ​ ↳ `hosted_url`        | `string`  | ✅       | —               |             |
+| ​ ↳ `submission_count`  | `number`  | ✅       | —               |             |
+| ​ ↳ `account_id`        | `number`  | ✅       | —               |             |
+| ​ ↳ `owner_id`          | `string`  | ✅       | —               |             |
+| ​ ↳ `created_at`        | `string`  | ✅       | —               |             |
+| ​ ↳ `updated_at`        | `string`  | ✅       | —               |             |
+| ​ ↳ `document`          | `unknown` | ✅       | —               |             |
+| ​ ↳ `last_published_at` | `string`  | ✅       | —               |             |
+| ​ ↳ `consumer_auth`     | `unknown` | ✅       | —               |             |
+| ​ ↳ `callback_url`      | `unknown` | ✅       | —               |             |
+
+**Example:**
+
+```typescript
+const { data: form } = await zapier.createForm({
+  title: "example-title",
+});
+```
+
 ### Tables
 
 #### `createTable`

package/dist/{chunk-Z7BGM75G.cjs → chunk-MGWFLOHA.cjs}

@@ -1541,6 +1541,11 @@ function declareOptionalProperty(config) {
     // import binding is still typed `TValue | undefined` from the descriptor.
   };
 }
+function declareDefault({
+  plugin
+}) {
+  return { ...plugin, defaultSource: plugin };
+}
 function defineHook(config) {
   const deps = normalizeImports(config.imports);
   return {
@@ -4210,6 +4215,321 @@ function createCorePlugin(options) {
     }
   });
 }
+function describeUnclaimedConnection(connection) {
+  const delimiterIndex = connection.indexOf(":");
+  if (delimiterIndex === -1) {
+    return 'no auth provider claimed this connection, and it carries no "scheme:" prefix';
+  }
+  return `no auth provider claimed the "${connection.slice(0, delimiterIndex)}" connection scheme`;
+}
+var authorizeHttpRequestPlugin = defineMethod({
+  name: "authorizeHttpRequest",
+  namespace: "kitcore",
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => {
+    const { connection } = input.request;
+    if (connection != null) {
+      throw createCoreError({
+        code: CoreErrorCode.Unknown,
+        message: `authorizeHttpRequest: ${describeUnclaimedConnection(connection)}, so the request was not sent.`
+      });
+    }
+    return input.request;
+  }
+});
+function toFetchInput(request) {
+  const init = { ...request };
+  const { url } = request;
+  delete init.url;
+  delete init.connection;
+  return { url, init };
+}
+var dispatchHttpRequestPlugin = defineMethod({
+  name: "dispatchHttpRequest",
+  namespace: "kitcore",
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => {
+    const { url, init } = toFetchInput(input.request);
+    return fetch(url, init);
+  }
+});
+var prepareHttpRequestPlugin = defineMethod({
+  name: "prepareHttpRequest",
+  namespace: "kitcore",
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => input.request
+});
+var receiveHttpResponsePlugin = defineMethod({
+  name: "receiveHttpResponse",
+  namespace: "kitcore",
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => input.response
+});
+var attemptHttpRequestPlugin = defineMethod({
+  name: "attemptHttpRequest",
+  namespace: "kitcore",
+  imports: [
+    declareDefault({ plugin: prepareHttpRequestPlugin }),
+    declareDefault({ plugin: authorizeHttpRequestPlugin }),
+    declareDefault({ plugin: dispatchHttpRequestPlugin }),
+    declareDefault({ plugin: receiveHttpResponsePlugin })
+  ],
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input, imports }) => {
+    const { attempt } = input;
+    const preparedRequest = await imports.prepareHttpRequest({
+      request: input.request,
+      attempt
+    });
+    const authorizedRequest = await imports.authorizeHttpRequest({
+      request: preparedRequest,
+      attempt
+    });
+    const response = await imports.dispatchHttpRequest({
+      request: authorizedRequest,
+      attempt
+    });
+    return imports.receiveHttpResponse({
+      request: authorizedRequest,
+      response,
+      attempt
+    });
+  }
+});
+function isReplayableBody(body) {
+  if (body == null || typeof body !== "object") return true;
+  return typeof Blob !== "undefined" && body instanceof Blob || // File extends Blob
+  typeof FormData !== "undefined" && body instanceof FormData || typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams || body instanceof ArrayBuffer || ArrayBuffer.isView(body);
+}
+function withStringUrl(request) {
+  return typeof request.url === "string" ? request : { ...request, url: String(request.url) };
+}
+var initializeHttpRequestPlugin = defineMethod({
+  name: "initializeHttpRequest",
+  namespace: "kitcore",
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => {
+    const request = withStringUrl(input.request);
+    return {
+      ...input.operation,
+      request,
+      replayable: isReplayableBody(request.body)
+    };
+  }
+});
+var RETRY_HTTP_REQUEST_OPTIONS_ID = "kitcore/retryHttpRequestOptions";
+var retryHttpRequestOptionsPluginRef = declareOptionalProperty({ id: RETRY_HTTP_REQUEST_OPTIONS_ID });
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_MAX_DELAY_MILLISECONDS = 6e4;
+var DEFAULT_RETRY_STATUSES = [429, 500, 502, 503, 504];
+var DEFAULT_NON_IDEMPOTENT_RETRY_STATUSES = [429];
+var DEFAULT_IDEMPOTENT_METHODS = [
+  "GET",
+  "HEAD",
+  "PUT",
+  "DELETE",
+  "OPTIONS",
+  "TRACE"
+];
+var BASE_BACKOFF_MILLISECONDS = 1e3;
+var JITTER_FACTOR = 0.5;
+function directedDelayMilliseconds(response) {
+  const retryAfter = response.headers.get("retry-after");
+  if (retryAfter) {
+    const seconds = Number.parseInt(retryAfter, 10);
+    if (!Number.isNaN(seconds)) return Math.max(0, seconds * 1e3);
+    const date = Date.parse(retryAfter);
+    if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+  }
+  const reset = response.headers.get("x-ratelimit-reset");
+  if (reset) {
+    const resetSeconds = Number.parseInt(reset, 10);
+    if (!Number.isNaN(resetSeconds)) {
+      return Math.max(0, resetSeconds * 1e3 - Date.now());
+    }
+  }
+  return void 0;
+}
+function backoffMilliseconds(attemptNumber) {
+  const base = BASE_BACKOFF_MILLISECONDS * 2 ** (attemptNumber - 1);
+  return base + Math.random() * JITTER_FACTOR * base;
+}
+function abortReason(signal) {
+  const reason = signal?.reason;
+  return reason ?? new Error("The request was aborted.");
+}
+function sleep(milliseconds, signal) {
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(finish, milliseconds);
+    function finish() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", cancel);
+      resolve2();
+    }
+    function cancel() {
+      clearTimeout(timer);
+      reject(abortReason(signal));
+    }
+    if (signal?.aborted) return cancel();
+    signal?.addEventListener("abort", cancel, { once: true });
+  });
+}
+function isIdempotent(request, idempotentMethods) {
+  const method = (request.method ?? "GET").toUpperCase();
+  return idempotentMethods.includes(method);
+}
+defineHook({
+  name: "retryHttpRequest",
+  imports: [attemptHttpRequestPlugin, retryHttpRequestOptionsPluginRef],
+  wrap: {
+    attemptHttpRequest: async ({ input, imports, next }) => {
+      const options = imports.retryHttpRequestOptions ?? {};
+      const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+      const maxDelayMilliseconds = options.maxDelayMilliseconds ?? DEFAULT_MAX_DELAY_MILLISECONDS;
+      const idempotentMethods = options.idempotentMethods ?? DEFAULT_IDEMPOTENT_METHODS;
+      const statuses = isIdempotent(input.request, idempotentMethods) ? options.retryStatuses ?? DEFAULT_RETRY_STATUSES : options.nonIdempotentRetryStatuses ?? DEFAULT_NON_IDEMPOTENT_RETRY_STATUSES;
+      for (let attemptNumber = 1; ; attemptNumber++) {
+        const attempt = {
+          ...input.attempt,
+          attemptNumber,
+          // Per-attempt scratch: a cross-stage handoff from a previous attempt
+          // describes a request that is no longer in flight. `operation` rides
+          // through unchanged, so the id and the caller's original request are
+          // the same for every attempt.
+          state: {}
+        };
+        let response;
+        try {
+          response = await next({ ...input, attempt });
+        } catch (error) {
+          if (!options.retryOnError || !canRetry(
+            attemptNumber,
+            maxAttempts,
+            input.attempt.operation.replayable
+          )) {
+            throw error;
+          }
+          await sleep(
+            Math.min(backoffMilliseconds(attemptNumber), maxDelayMilliseconds),
+            attempt.signal
+          );
+          continue;
+        }
+        if (!statuses.includes(response.status) || !canRetry(
+          attemptNumber,
+          maxAttempts,
+          input.attempt.operation.replayable
+        )) {
+          return response;
+        }
+        const directed = directedDelayMilliseconds(response);
+        if (directed != null && directed > maxDelayMilliseconds)
+          return response;
+        const delay = Math.min(
+          directed ?? backoffMilliseconds(attemptNumber),
+          maxDelayMilliseconds
+        );
+        await response.body?.cancel().catch(() => {
+        });
+        await sleep(delay, attempt.signal);
+      }
+    }
+  }
+});
+function canRetry(attemptNumber, maxAttempts, replayable) {
+  return attemptNumber < maxAttempts && replayable;
+}
+function createOperationId() {
+  return globalThis.crypto?.randomUUID?.() ?? `http-${Date.now()}`;
+}
+var sendHttpRequestPlugin = defineMethod({
+  name: "sendHttpRequest",
+  namespace: "kitcore",
+  imports: [
+    declareDefault({ plugin: initializeHttpRequestPlugin }),
+    declareDefault({ plugin: attemptHttpRequestPlugin })
+  ],
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input, imports }) => {
+    const start2 = {
+      operationId: createOperationId(),
+      signal: input.signal
+    };
+    const operation = await imports.initializeHttpRequest({
+      request: input,
+      operation: start2
+    });
+    return imports.attemptHttpRequest({
+      request: operation.request,
+      attempt: {
+        attemptNumber: 1,
+        operation,
+        signal: operation.signal,
+        state: {}
+      }
+    });
+  }
+});
+defineMethod({
+  name: "fetch",
+  namespace: "kitcore",
+  imports: [declareDefault({ plugin: sendHttpRequestPlugin })],
+  positional: ["url", "init"],
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: ({ input, imports }) => {
+    const { url, init } = input;
+    return imports.sendHttpRequest({ url, ...init });
+  }
+});
+var defaultConnectionSchemePlugin = defineMethod({
+  name: "defaultConnectionScheme",
+  namespace: "kitcore",
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: () => void 0
+});
+defineMethod({
+  name: "normalizeConnection",
+  namespace: "kitcore",
+  imports: [declareDefault({ plugin: defaultConnectionSchemePlugin })],
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: ({ input, imports }) => {
+    const { connection } = input;
+    if (connection == null) {
+      return void 0;
+    }
+    const delimiterIndex = connection.indexOf(":");
+    if (delimiterIndex !== -1) {
+      return {
+        connection,
+        scheme: connection.slice(0, delimiterIndex),
+        value: connection.slice(delimiterIndex + 1)
+      };
+    }
+    const scheme = imports.defaultConnectionScheme({ connection });
+    return {
+      connection,
+      scheme,
+      value: connection
+    };
+  }
+});
+defineMethod({
+  name: "resolveConnection",
+  namespace: "kitcore",
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: ({ input }) => input.connection
+});
 
 // src/constants.ts
 var ZAPIER_BASE_URL = globalThis.process?.env?.ZAPIER_BASE_URL || "https://zapier.com";
@@ -4914,9 +5234,9 @@ function createDebugFetch(options) {
 var MAX_CONSECUTIVE_ERRORS = 3;
 var BASE_ERROR_BACKOFF_MILLISECONDS = 1e3;
 var BASE_EXPONENTIAL_BACKOFF_MILLISECONDS = 1e3;
-var JITTER_FACTOR = 0.5;
+var JITTER_FACTOR2 = 0.5;
 function calculateErrorBackoffMs(baseInterval, errorCount) {
-  const jitter = Math.random() * JITTER_FACTOR * baseInterval;
+  const jitter = Math.random() * JITTER_FACTOR2 * baseInterval;
   const errorBackoff = Math.min(
     BASE_ERROR_BACKOFF_MILLISECONDS * (errorCount / 2),
     baseInterval * 2
@@ -4926,10 +5246,10 @@ function calculateErrorBackoffMs(baseInterval, errorCount) {
 }
 function calculateExponentialBackoffMs(attempt, baseDelayMs = BASE_EXPONENTIAL_BACKOFF_MILLISECONDS) {
   const baseDelay = baseDelayMs * Math.pow(2, attempt - 1);
-  const jitter = Math.random() * JITTER_FACTOR * baseDelay;
+  const jitter = Math.random() * JITTER_FACTOR2 * baseDelay;
   return Math.floor(baseDelay + jitter);
 }
-function sleep(ms, signal) {
+function sleep2(ms, signal) {
   if (!signal) {
     return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
@@ -5141,7 +5461,7 @@ async function pollUntilComplete(options) {
   let attempts = 0;
   let errorCount = 0;
   if (initialDelay > 0) {
-    await sleep(initialDelay, signal);
+    await sleep2(initialDelay, signal);
     if (signal?.aborted) throw makeAbortError();
   }
   while (true) {
@@ -5159,7 +5479,7 @@ async function pollUntilComplete(options) {
       const interval = getPollingInterval(elapsedTime);
       const waitTime = calculateErrorBackoffMs(interval, errorCount);
       const cappedWaitTime = maxPollingIntervalMs === void 0 ? waitTime : Math.min(waitTime, maxPollingIntervalMs);
-      await sleep(cappedWaitTime, signal);
+      await sleep2(cappedWaitTime, signal);
       if (signal?.aborted) throw makeAbortError();
     }
     attempts++;
@@ -6194,7 +6514,7 @@ function parseDeprecationDate(value) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.95.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.96.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -6428,6 +6748,15 @@ var pathConfig = {
   "/code-substrate-workflows": {
     authHeader: "Authorization",
     pathPrefix: "/api/v0/sdk/code-substrate-workflows"
+  },
+  // 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 {
@@ -6490,7 +6819,7 @@ var ZapierApiClient = class {
           method: init?.method ?? "GET",
           rateLimit: rateLimitInfo
         });
-        await sleep(delayMs, init?.signal ?? void 0);
+        await sleep2(delayMs, init?.signal ?? void 0);
       }
     };
     /**
@@ -6968,7 +7297,8 @@ var ZapierApiClient = class {
     const zapierBaseUrl = getZapierBaseUrl(this.options.baseUrl);
     if (zapierBaseUrl === this.options.baseUrl.replace(/\/$/, "")) {
       const originalBaseUrl = new URL(this.options.baseUrl);
-      const finalBaseUrl = `https://sdkapi.${originalBaseUrl.hostname}`;
+      const subdomain = routingMatch?.config.subdomain ?? "sdkapi";
+      const finalBaseUrl = `https://${subdomain}.${originalBaseUrl.hostname}`;
       const url2 = new URL(finalPath, finalBaseUrl);
       return buildResult(url2);
     }
@@ -8373,7 +8703,7 @@ function buildAbortHandle({
   return combineAbortSignals({ handles });
 }
 var FetchInitSdkValidationSchema = zod.z.looseObject(FetchInitZapierFieldsSchema.shape).optional();
-var fetchPlugin = defineMethod({
+var fetchPlugin2 = defineMethod({
   name: "fetch",
   imports: [coreOptionsPluginRef, connectionsPluginRef, apiPluginRef],
   output: "raw",
@@ -10705,7 +11035,7 @@ function createAppsProxy(imports) {
 }
 var appsPlugin = defineProperty({
   name: "apps",
-  imports: [fetchPlugin, runActionPlugin],
+  imports: [fetchPlugin2, runActionPlugin],
   // Build the proxy once from the imported methods (stable callables).
   setup: ({ imports }) => (
     // Cast: ZapierSdkApps is augmented by user-generated .d.ts files to give
@@ -12059,7 +12389,7 @@ var RelayFetchSchema = RelayRequestSchema;
 // src/plugins/request/index.ts
 var requestPlugin = defineMethod({
   name: "request",
-  imports: [fetchPlugin, coreOptionsPluginRef],
+  imports: [fetchPlugin2, coreOptionsPluginRef],
   output: "raw",
   inputSchema: RelayRequestSchema,
   skipInputValidation: true,
@@ -13884,7 +14214,7 @@ async function drainRunner({
           `[zapier-sdk] Retrying drain for inbox ${inboxId} (attempt ${errorAttempts}, retry in ${delay}ms)${httpPart}: ${errorMessage(error)}`
         );
       }
-      await sleep(delay, signal);
+      await sleep2(delay, signal);
       if (signal.aborted) return { kind: "aborted" };
       drainRequest.request();
       continue;
@@ -13951,7 +14281,7 @@ async function sseLoop({
         }
         attempt = 0;
         if (signal.aborted) return;
-        await sleep(safetyDrainMs, signal);
+        await sleep2(safetyDrainMs, signal);
         continue;
       }
       if (connected) attempt = 0;
@@ -13971,7 +14301,7 @@ async function sseLoop({
         `[zapier-sdk] Reconnecting real-time wake-ups for inbox ${inboxId} (attempt ${attempt}, retry in ${delay}ms)${httpPart}: ${errorMsg}`
       );
     }
-    await sleep(delay, signal);
+    await sleep2(delay, signal);
   }
 }
 async function safetyTimerLoop({
@@ -13980,7 +14310,7 @@ async function safetyTimerLoop({
   signal
 }) {
   while (!signal.aborted) {
-    await sleep(safetyDrainMs, signal);
+    await sleep2(safetyDrainMs, signal);
     if (signal.aborted) return;
     drainRequest.request();
   }
@@ -15862,7 +16192,7 @@ var zapierSdkPlugin = definePlugin({
     createActionRunPlugin,
     getActionRunPlugin,
     runActionPlugin,
-    fetchPlugin,
+    fetchPlugin2,
     requestPlugin,
     appsPlugin,
     // Triggers. `list*` plugins are exported before their `get*` / mutation
@@ -15946,7 +16276,7 @@ async function batch(tasks, options = {}) {
     try {
       let result;
       if (taskTimeoutMs !== void 0) {
-        const timeoutPromise = sleep(taskTimeoutMs).then(() => {
+        const timeoutPromise = sleep2(taskTimeoutMs).then(() => {
           throw new ZapierTimeoutError(
             `Task timed out after ${taskTimeoutMs}ms`
           );
@@ -15961,7 +16291,7 @@ async function batch(tasks, options = {}) {
       const isTimeout = isZapierTimeoutError(error);
       if (retry && !isTimeout && newErrorCount < MAX_CONSECUTIVE_ERRORS) {
         const waitTime = calculateErrorBackoffMs(1e3, newErrorCount);
-        await sleep(waitTime);
+        await sleep2(waitTime);
         taskQueue.push({
           index,
           task,
@@ -15984,7 +16314,7 @@ async function batch(tasks, options = {}) {
       if (!taskState) break;
       await executeTask(taskState);
       if (taskQueue.length > 0 && batchDelay > 0) {
-        await sleep(batchDelay);
+        await sleep2(batchDelay);
       }
     }
   }
@@ -15993,7 +16323,7 @@ async function batch(tasks, options = {}) {
   for (let i = 0; i < workerCount; i++) {
     workers.push(worker());
     if (i < workerCount - 1 && batchDelay > 0) {
-      await sleep(batchDelay / 10);
+      await sleep2(batchDelay / 10);
     }
   }
   await Promise.all(workers);
@@ -16228,7 +16558,7 @@ exports.eventEmissionHookPlugin = eventEmissionHookPlugin;
 exports.eventEmissionPlugin = eventEmissionPlugin;
 exports.eventEmissionPluginRef = eventEmissionPluginRef;
 exports.extractErrorDetail = extractErrorDetail;
-exports.fetchPlugin = fetchPlugin;
+exports.fetchPlugin = fetchPlugin2;
 exports.findFirstConnectionPlugin = findFirstConnectionPlugin;
 exports.findManifestEntry = findManifestEntry;
 exports.findUniqueConnectionPlugin = findUniqueConnectionPlugin;