@zapier/zapier-sdk 0.77.2 → 0.79.0

package/dist/experimental.mjs

@@ -50,6 +50,7 @@ function canonicalInputSchema(schema) {
 function buildRegistry({
   sdk,
   meta,
+  formatters,
   packageFilter
 }) {
   const definitionsByKey = /* @__PURE__ */ new Map();
@@ -90,7 +91,7 @@ function buildRegistry({
         (c) => typeof c === "string" ? c : c.key
       ),
       resolvers: m.resolvers,
-      formatter: m.formatter,
+      formatter: formatters?.[key],
       experimental: m.experimental,
       packages: m.packages,
       confirm: m.confirm ?? (m.type === "delete" ? "delete" : void 0),
@@ -516,8 +517,8 @@ function normalizeError(error, adaptError) {
   );
 }
 function createFunction(coreFn, options) {
-  const { sdk, schema } = options;
-  const functionName = coreFn.name;
+  const { sdk, schema, name } = options;
+  const functionName = name || coreFn.name;
   const namedFunctions = {
     [functionName]: async function(callOptions) {
       return runInMethodScope(async () => {
@@ -692,9 +693,6 @@ function createPaginatedFunction(coreFn, options) {
   };
   return namedFunctions[functionName];
 }
-function definePlugin(fn) {
-  return fn;
-}
 function createPluginMethod(sdk, config) {
   const { name, inputSchema, handler, ...metaFields } = config;
   const namedHandlers = {
@@ -763,8 +761,7 @@ function splitPluginContribution(result) {
 }
 var RESERVED_ROOT_KEYS = /* @__PURE__ */ new Set([
   "context",
-  "getRegistry",
-  "addPlugin"
+  "getRegistry"
 ]);
 function hasOwn(obj, key) {
   return Object.prototype.hasOwnProperty.call(obj, key);
@@ -778,15 +775,28 @@ function setOwn(target, key, value) {
   });
 }
 function checkCollisions(target, source, kind, callerLabel, override) {
+  if (kind === "root key") {
+    checkRootKeyCollisions(target, Object.keys(source), override, callerLabel);
+    return;
+  }
   for (const key of Object.keys(source)) {
-    if (kind === "root key" && RESERVED_ROOT_KEYS.has(key)) {
+    if (!override && hasOwn(target, key)) {
+      throw new Error(
+        `${callerLabel}: duplicate ${kind} "${key}". If the override is intentional, pass { override: true } in the options.`
+      );
+    }
+  }
+}
+function checkRootKeyCollisions(target, keys, override, callerLabel) {
+  for (const key of keys) {
+    if (RESERVED_ROOT_KEYS.has(key)) {
       throw new Error(
         `${callerLabel}: plugin attempted to register reserved root key "${key}". The SDK uses this key for its own accessor; rename the plugin's method.`
       );
     }
     if (!override && hasOwn(target, key)) {
       throw new Error(
-        `${callerLabel}: duplicate ${kind} "${key}". If the override is intentional, pass { override: true } in the options.`
+        `${callerLabel}: duplicate root key "${key}". If the override is intentional, pass { override: true } in the options.`
       );
     }
   }
@@ -837,7 +847,7 @@ function mergeContribution(propertiesTarget, contextTarget, contribution, option
 function applyPluginContribution(acc, contribution, options) {
   mergeContribution(acc.view, acc.context, contribution, options);
 }
-function wrapAsSdk(properties, context, opts) {
+function wrapAsSdk(properties, context) {
   const sdk = {
     ...properties,
     context,
@@ -849,9 +859,6 @@ function wrapAsSdk(properties, context, opts) {
       });
     }
   };
-  if (opts?.addPlugin !== void 0) {
-    sdk.addPlugin = opts.addPlugin;
-  }
   return sdk;
 }
 function wrapAccumulatorAsSdk(acc) {
@@ -870,126 +877,92 @@ function applyPluginToSdk(sdk, plugin, options) {
     callerLabel: "addPlugin",
     override: options.override === true
   });
+  return contribution;
 }
-function buildStackAccumulator(head, callerLabel) {
-  const ordered = [];
+function resolveStack(head) {
+  const entries = [];
   let node = head;
   while (node) {
-    ordered.unshift(node);
+    entries.unshift({ apply: node.entry, override: node.override });
     node = node.prev;
   }
-  const acc = createPluginAccumulator();
-  for (const { plugin, override } of ordered) {
-    const contribution = splitPluginContribution(
-      plugin(acc.view)
-    );
-    applyPluginContribution(acc, contribution, { callerLabel, override });
-  }
-  return acc;
-}
-function addPlugin(sdk, plugin, options) {
-  applyPluginToSdk(
-    sdk,
-    plugin,
-    options ?? {}
-  );
+  return entries;
+}
+function composeStackHooks(hooks) {
+  let composed = {};
+  for (const h of hooks) composed = buildHooks(composed, h);
+  return composed;
+}
+function collapseStackEntries(entries, callerLabel) {
+  return (outerSdk) => {
+    const { context: outerContext, ...outerProperties } = outerSdk ?? {};
+    const viewAcc = createPluginAccumulator(outerProperties, outerContext);
+    const contribsAcc = createPluginAccumulator();
+    const hooks = [];
+    for (const { apply, override } of entries) {
+      const contribution = splitPluginContribution(
+        apply(viewAcc.view)
+      );
+      const hookless = { ...contribution, hooks: {} };
+      applyPluginContribution(viewAcc, hookless, { callerLabel, override });
+      applyPluginContribution(contribsAcc, hookless, { callerLabel, override });
+      hooks.push(contribution.hooks);
+    }
+    const stackHooks = composeStackHooks(hooks);
+    viewAcc.context.hooks = buildHooks(viewAcc.context.hooks, stackHooks);
+    contribsAcc.context.hooks = stackHooks;
+    const { context: _ignored, ...contributedRoot } = contribsAcc.view;
+    return {
+      ...contributedRoot,
+      context: contribsAcc.context
+    };
+  };
 }
-function buildSdk(properties, context) {
-  const addPlugin2 = (plugin, options) => {
-    logDeprecation(
-      "sdk.addPlugin(plugin) (the chain-style extension) is deprecated. Build the SDK in one pass with createPluginStack().use(...).toSdk() instead \u2014 each .toSdk() produces fresh plugin closures and avoids the closure-sharing semantics that caused this to be deprecated."
-    );
+function buildStackAccumulator(head, callerLabel) {
+  const entries = resolveStack(head);
+  const acc = createPluginAccumulator();
+  const hooks = [];
+  for (const { apply, override } of entries) {
     const contribution = splitPluginContribution(
-      plugin({ ...properties, context })
+      apply(acc.view)
     );
-    const mergedProperties = { ...properties };
-    const mergedContext = {
-      ...context,
-      meta: { ...context.meta },
-      hooks: { ...context.hooks }
-    };
-    mergeContribution(mergedProperties, mergedContext, contribution, {
-      callerLabel: "addPlugin",
-      override: options?.override === true
-    });
-    return buildSdk(
-      mergedProperties,
-      mergedContext
+    applyPluginContribution(
+      acc,
+      { ...contribution, hooks: {} },
+      { callerLabel, override }
     );
-  };
-  return wrapAsSdk(properties, context, { addPlugin: addPlugin2 });
-}
-function withDeprecatedAddPlugin(sdk) {
-  const initialProperties = {};
-  for (const key of Object.keys(sdk)) {
-    if (key === "context" || key === "getRegistry" || key === "addPlugin") {
-      continue;
-    }
-    initialProperties[key] = sdk[key];
+    hooks.push(contribution.hooks);
   }
-  const initialContext = sdk.context;
-  return buildSdk(
-    initialProperties,
-    initialContext
-  );
+  acc.context.hooks = composeStackHooks(hooks);
+  return acc;
 }
 function composePlugins(...plugins) {
   logDeprecation(
-    "composePlugins(...) is deprecated. Use createPluginStack().use(a).use(b).use(c).toPlugin() instead. The stack carries the same collision-detection and hook-composition behavior, supports per-step { override: true } for intentional duplicates, and progressively narrows types so dependency mistakes surface at the specific .use call."
-  );
-  let stack = buildPluginStack(
-    null,
-    "composePlugins"
+    "composePlugins(...) is deprecated. Use createPluginStack().use(a).use(b).use(c).toPlugin({ name }) instead. The stack carries the same collision-detection and hook-composition behavior and supports per-step { override: true } for intentional duplicates."
   );
+  let head = null;
   for (const plugin of plugins) {
-    stack = stack.use(plugin);
+    head = { entry: plugin, override: false, prev: head };
   }
-  return stack.toPlugin();
+  const entries = resolveStack(head);
+  return collapseStackEntries(entries, "composePlugins");
 }
 function createPluginStack() {
   return buildPluginStack(null, "createPluginStack");
 }
 function buildPluginStack(head, callerLabel) {
-  return {
+  const stack = {
     use(plugin, options) {
       const next = {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        plugin,
+        entry: plugin,
         override: options?.override === true,
         prev: head
       };
       return buildPluginStack(next, callerLabel);
     },
     toPlugin() {
-      const ordered = [];
-      let node = head;
-      while (node) {
-        ordered.unshift(node);
-        node = node.prev;
-      }
-      return (outerSdk) => {
-        const { context: outerContext, ...outerProperties } = outerSdk ?? {};
-        const viewAcc = createPluginAccumulator(outerProperties, outerContext);
-        const contribsAcc = createPluginAccumulator();
-        for (const { plugin: subPlugin, override } of ordered) {
-          const contribution = splitPluginContribution(
-            subPlugin(viewAcc.view)
-          );
-          applyPluginContribution(viewAcc, contribution, {
-            callerLabel,
-            override
-          });
-          applyPluginContribution(contribsAcc, contribution, {
-            callerLabel,
-            override
-          });
-        }
-        const { context: _ignored, ...contributedRoot } = contribsAcc.view;
-        return {
-          ...contributedRoot,
-          context: contribsAcc.context
-        };
-      };
+      const entries = resolveStack(head);
+      return collapseStackEntries(entries, callerLabel);
     },
     toSdk() {
       return wrapAccumulatorAsSdk(
@@ -997,6 +970,891 @@ function buildPluginStack(head, callerLabel) {
       );
     }
   };
+  return stack;
+}
+function parseId(id) {
+  const at = id.lastIndexOf("/");
+  return at === -1 ? { name: id, namespace: void 0 } : { name: id.slice(at + 1), namespace: id.slice(0, at) };
+}
+function makeId(name, namespace, kind = "leaf") {
+  validateName(name, kind);
+  if (namespace !== void 0) validateNamespace(namespace);
+  return namespace ? `${namespace}/${name}` : name;
+}
+var NAME_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var SEGMENT_RE = /^@?[A-Za-z0-9._-]+$/;
+function validateName(name, kind) {
+  if (name === "") throw new Error("Plugin name must not be empty.");
+  if (kind === "leaf") {
+    if (!NAME_RE.test(name)) {
+      throw new Error(
+        `Plugin name "${name}" must be a valid JS identifier (it is the binding name).`
+      );
+    }
+  } else if (!SEGMENT_RE.test(name)) {
+    throw new Error(
+      `Plugin name "${name}" must be package-like (letters, digits, ".", "_", "-", optional leading "@") with no "/".`
+    );
+  }
+}
+function validateNamespace(namespace) {
+  if (namespace === "") throw new Error("Plugin namespace must not be empty.");
+  for (const segment of namespace.split("/")) {
+    if (!SEGMENT_RE.test(segment)) {
+      throw new Error(
+        `Plugin namespace "${namespace}" is invalid: each "/"-separated segment must be package-like (letters, digits, ".", "_", "-", optional leading "@").`
+      );
+    }
+  }
+}
+var LEAF_META_KEYS = [
+  "description",
+  "categories",
+  "type",
+  "itemType",
+  "returnType",
+  "outputSchema",
+  "inputParameters",
+  "packages",
+  "experimental",
+  "confirm",
+  "deprecation",
+  "aliases",
+  "supportsJsonOutput"
+];
+function normalizeImports(deps) {
+  if (!deps) return { plugins: [], bindings: [] };
+  const seen = /* @__PURE__ */ new Map();
+  const bindings = [];
+  const add = (binding, id) => {
+    const priorId = seen.get(binding);
+    if (priorId !== void 0 && priorId !== id) {
+      throw new Error(
+        `Import binding "${binding}" is declared twice. Two different plugins ("${priorId}" and "${id}") bind the same name; wrap one in selectExports to rename it.`
+      );
+    }
+    if (priorId === void 0) {
+      seen.set(binding, id);
+      bindings.push({ binding, id });
+    }
+  };
+  for (const plugin of deps) {
+    if (plugin.pluginType === "aggregate") {
+      for (const [binding, child] of Object.entries(plugin.exports)) {
+        add(binding, child.id);
+      }
+    } else {
+      add(plugin.name, plugin.id);
+    }
+  }
+  return { plugins: deps, bindings };
+}
+function collectLeafMeta(config) {
+  let meta;
+  for (const key of LEAF_META_KEYS) {
+    if (config[key] !== void 0) (meta ?? (meta = {}))[key] = config[key];
+  }
+  return meta;
+}
+function defineMethod(config) {
+  const deps = normalizeImports(config.imports);
+  return {
+    pluginType: "method",
+    name: config.name,
+    namespace: config.namespace,
+    id: makeId(config.name, config.namespace),
+    imports: deps.plugins,
+    importBindings: deps.bindings,
+    inputSchema: config.inputSchema,
+    meta: collectLeafMeta(config),
+    resolvers: config.resolvers,
+    formatter: config.formatter,
+    output: config.output,
+    positional: config.positional,
+    setup: config.setup,
+    run: config.run
+  };
+}
+function defineFormatter(config) {
+  const deps = normalizeImports(config.imports);
+  return {
+    imports: deps.plugins,
+    importBindings: deps.bindings,
+    fetchContext: config.fetchContext,
+    format: config.format
+  };
+}
+function declareMethod(config) {
+  const { name, namespace } = parseId(config.id);
+  const id = makeId(name, namespace);
+  return {
+    pluginType: "method",
+    name,
+    namespace,
+    id,
+    standIn: true,
+    imports: [],
+    importBindings: [],
+    run: () => {
+      throw new Error(
+        `Plugin "${id}" is a stand-in (declareMethod) with no implementation. Register the real plugin under this id.`
+      );
+    }
+  };
+}
+function defineProperty(config) {
+  const deps = normalizeImports(config.imports);
+  return {
+    pluginType: "property",
+    name: config.name,
+    namespace: config.namespace,
+    id: makeId(config.name, config.namespace),
+    imports: deps.plugins,
+    importBindings: deps.bindings,
+    setup: config.setup,
+    value: config.value,
+    get: config.get,
+    meta: collectLeafMeta(config)
+  };
+}
+function declareProperty(config) {
+  const { name, namespace } = parseId(config.id);
+  return {
+    pluginType: "property",
+    name,
+    namespace,
+    id: makeId(name, namespace),
+    standIn: true,
+    imports: [],
+    importBindings: []
+  };
+}
+function definePlugin(fnOrConfig) {
+  if (typeof fnOrConfig === "function") return fnOrConfig;
+  const config = fnOrConfig;
+  const deps = normalizeImports(config.imports);
+  return {
+    pluginType: "aggregate",
+    name: config.name,
+    namespace: config.namespace,
+    id: makeId(config.name, config.namespace, "aggregate"),
+    imports: deps.plugins,
+    importBindings: deps.bindings,
+    exports: normalizeExports(config.exports),
+    middleware: config.middleware
+  };
+}
+function normalizeExports(exports) {
+  if (!exports) return {};
+  const out = {};
+  const add = (binding, leaf) => {
+    const existing = out[binding];
+    if (existing && existing.id !== leaf.id) {
+      throw new Error(
+        `definePlugin: duplicate export binding "${binding}". Two different plugins ("${existing.id}" and "${leaf.id}") bind the same name; wrap one in selectExports to rename it.`
+      );
+    }
+    out[binding] = leaf;
+  };
+  for (const element of exports) {
+    if (element.pluginType === "aggregate") {
+      for (const [binding, child] of Object.entries(element.exports)) {
+        add(binding, child);
+      }
+    } else {
+      add(element.name, element);
+    }
+  }
+  return out;
+}
+function fromFunctionPlugin(fn, config) {
+  return {
+    pluginType: "legacy",
+    name: config.name,
+    namespace: config.namespace,
+    id: makeId(config.name, config.namespace, "aggregate"),
+    imports: [],
+    importBindings: [],
+    run: fn
+  };
+}
+function defineLegacyMerge(args) {
+  return {
+    pluginType: "legacy-merge",
+    name: args.name,
+    namespace: args.namespace,
+    id: makeId(args.name, args.namespace, "aggregate"),
+    legacy: fromFunctionPlugin(args.legacy, {
+      name: args.name,
+      namespace: args.namespace
+    }),
+    plugin: args.plugin
+  };
+}
+function legacyGraphEntry(name, value, pluginMeta) {
+  const { inputSchema, ...rest } = pluginMeta ?? {};
+  const meta = Object.keys(rest).length ? rest : void 0;
+  if (typeof value === "function") {
+    return {
+      pluginType: "method",
+      name,
+      value,
+      chain: [],
+      ...inputSchema ? { inputSchema } : {},
+      ...meta ? { meta } : {}
+    };
+  }
+  return { pluginType: "property", name, value, ...meta ? { meta } : {} };
+}
+function adaptLegacyFormatter(legacy, sdk) {
+  const legacyFetch = legacy.fetch;
+  return {
+    fetchContext: legacyFetch ? async ({ items, input, context }) => {
+      let ctx = context;
+      for (const item of items) {
+        ctx = await legacyFetch(sdk, input, item, ctx);
+      }
+      return ctx;
+    } : void 0,
+    format: ({ item, context }) => legacy.format(item, context)
+  };
+}
+function normalizeFormatter(entry, sdk) {
+  if (entry.pluginType !== "method") return void 0;
+  if (entry.formatter) return entry.formatter;
+  const legacy = entry.meta?.formatter;
+  return legacy ? adaptLegacyFormatter(legacy, sdk) : void 0;
+}
+function pluginEntryMeta(entry) {
+  if (entry.pluginType === "method" && entry.meta) {
+    return entry.inputSchema ? { ...entry.meta, inputSchema: entry.inputSchema } : entry.meta;
+  }
+  if (entry.pluginType === "property" && entry.meta) return entry.meta;
+  return void 0;
+}
+function buildSurfaceRegistry(context, packageFilter) {
+  const meta = {};
+  const surface = {};
+  const entries = {};
+  for (const [binding, id] of Object.entries(context.surface)) {
+    const entry = context.plugins[id];
+    if (!entry || entry.pluginType === "aggregate") continue;
+    surface[binding] = entry.value;
+    entries[binding] = entry;
+    const m = pluginEntryMeta(entry);
+    if (m) meta[binding] = m;
+  }
+  const formatters = {};
+  for (const [binding, entry] of Object.entries(entries)) {
+    const f = normalizeFormatter(entry, surface);
+    if (f) formatters[binding] = f;
+  }
+  return buildRegistry({ sdk: surface, meta, formatters, packageFilter });
+}
+var dangerousContextPlugin = {
+  pluginType: "property",
+  name: "context",
+  namespace: "kitcore",
+  id: "kitcore/context",
+  imports: [],
+  importBindings: [],
+  privileged: true
+};
+defineMethod({
+  name: "getRegistry",
+  namespace: "kitcore",
+  imports: [dangerousContextPlugin],
+  inputSchema: z.object({ package: z.string().optional() }).optional(),
+  run: ({ imports, input }) => buildSurfaceRegistry(imports.context, input?.package)
+});
+function normalizeOutput(output) {
+  if (output === void 0) return { type: "raw" };
+  if (typeof output === "string") return { type: output };
+  return output;
+}
+var CONTEXT = Symbol("kitcore.context");
+function getContext(sdk) {
+  return sdk[CONTEXT];
+}
+function isResolverRef(value) {
+  return "ref" in value;
+}
+function nestedResolvers(resolver) {
+  const out = [];
+  if (resolver.type === "object") {
+    for (const field of Object.values(resolver.properties ?? {})) {
+      if (!isResolverRef(field.resolver)) out.push(field.resolver);
+    }
+    out.push(...Object.values(resolver.definitions ?? {}));
+  } else if (resolver.type === "array") {
+    if (!isResolverRef(resolver.items)) out.push(resolver.items);
+    out.push(...Object.values(resolver.definitions ?? {}));
+  }
+  return out;
+}
+function resolverImportEdges(resolver) {
+  const out = [...resolver.imports];
+  for (const child of nestedResolvers(resolver)) {
+    out.push(...resolverImportEdges(child));
+  }
+  return out;
+}
+function methodAttachmentEdges(plugin) {
+  const out = [];
+  if (plugin.resolvers) {
+    for (const resolver of Object.values(plugin.resolvers)) {
+      out.push(...resolverImportEdges(resolver));
+    }
+  }
+  if (plugin.formatter) out.push(...plugin.formatter.imports);
+  return out;
+}
+function edgesOf(plugin) {
+  if (plugin.pluginType === "aggregate") {
+    return [...Object.values(plugin.exports), ...plugin.imports];
+  }
+  if (plugin.pluginType === "method") {
+    return [...plugin.imports, ...methodAttachmentEdges(plugin)];
+  }
+  return plugin.imports;
+}
+function isStandIn(plugin) {
+  return (plugin.pluginType === "method" || plugin.pluginType === "property" || plugin.pluginType === "aggregate") && plugin.standIn === true;
+}
+function topoOrder(descriptors) {
+  const order = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (visited.has(id)) return;
+    visited.add(id);
+    const descriptor = descriptors.get(id);
+    if (descriptor) for (const edge of edgesOf(descriptor)) visit(edge.id);
+    order.push(id);
+  };
+  for (const id of descriptors.keys()) visit(id);
+  return order;
+}
+function collectPlugins(root, materialized = /* @__PURE__ */ new Set()) {
+  const byId = /* @__PURE__ */ new Map();
+  const visit = (plugin) => {
+    if (materialized.has(plugin.id)) return;
+    const existing = byId.get(plugin.id);
+    if (existing === plugin) return;
+    if (existing) {
+      const bothReal = !isStandIn(existing) && !isStandIn(plugin);
+      if (bothReal) {
+        throw new Error(
+          `createSdk: duplicate plugin id "${plugin.id}". Two different plugins registered under the same id.`
+        );
+      }
+      if (isStandIn(existing) && !isStandIn(plugin)) {
+        byId.set(plugin.id, plugin);
+        for (const edge of edgesOf(plugin)) visit(edge);
+      }
+      return;
+    }
+    byId.set(plugin.id, plugin);
+    for (const edge of edgesOf(plugin)) visit(edge);
+  };
+  visit(root);
+  for (const [id, plugin] of byId) {
+    if (isStandIn(plugin)) {
+      throw new Error(
+        `createSdk: missing dependency "${id}". A plugin depends on it (via a stand-in) but no implementation was registered.`
+      );
+    }
+  }
+  return byId;
+}
+function bindValue(target, key, entry) {
+  if (entry.pluginType === "property" && entry.getValue) {
+    Object.defineProperty(target, key, {
+      get: entry.getValue,
+      enumerable: true,
+      configurable: true
+    });
+  } else {
+    Object.defineProperty(target, key, {
+      value: entry.value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+  }
+}
+function buildSurface(context, ...maps) {
+  const sdk = {};
+  for (const map of maps) {
+    Object.defineProperties(sdk, Object.getOwnPropertyDescriptors(map));
+  }
+  sdk.context = context;
+  sdk[CONTEXT] = context;
+  return sdk;
+}
+function buildImports(plugins, importBindings) {
+  const imports = {};
+  for (const { binding, id } of importBindings) {
+    bindValue(imports, binding, plugins[id]);
+  }
+  return imports;
+}
+function mirrorLegacyRootKeys(context, rootKeys, meta) {
+  const exports = {};
+  for (const [name, value] of Object.entries(rootKeys)) {
+    context.plugins[name] = legacyGraphEntry(name, value, meta[name]);
+    exports[name] = value;
+  }
+  return exports;
+}
+function recordExportSurface(context, exports) {
+  for (const [binding, child] of Object.entries(exports)) {
+    context.surface[binding] = child.id;
+  }
+}
+function materialize(descriptors, context) {
+  const states = /* @__PURE__ */ new Map();
+  runLegacyPass(descriptors, context);
+  buildMethodEntries(descriptors, context, states);
+  buildEagerArtifacts(descriptors, context, states);
+  bindAttachments(descriptors, context);
+  resolveAggregates(descriptors, context);
+  assembleMiddleware(descriptors, context);
+  return context.plugins;
+}
+function bindResolver(resolver, plugins) {
+  switch (resolver.type) {
+    case "static":
+      return {
+        type: "static",
+        requireParams: resolver.requireParams,
+        requireCapabilities: resolver.requireCapabilities,
+        inputType: resolver.inputType,
+        placeholder: resolver.placeholder
+      };
+    case "constant":
+      return {
+        type: "constant",
+        value: resolver.value,
+        requireParams: resolver.requireParams,
+        requireCapabilities: resolver.requireCapabilities
+      };
+    case "info":
+      return { type: "info", text: resolver.text };
+    case "object": {
+      const imports = buildImports(plugins, resolver.importBindings);
+      const bound = {
+        type: "object",
+        requireParams: resolver.requireParams,
+        requireCapabilities: resolver.requireCapabilities
+      };
+      if (resolver.properties)
+        bound.properties = bindFields(resolver.properties, plugins);
+      if (resolver.definitions)
+        bound.definitions = bindDefinitions(resolver.definitions, plugins);
+      const { fetch: fetch2 } = resolver;
+      if (fetch2) bound.fetch = ({ params }) => fetch2({ imports, params });
+      return bound;
+    }
+    case "array": {
+      const bound = {
+        type: "array",
+        requireParams: resolver.requireParams,
+        requireCapabilities: resolver.requireCapabilities,
+        minItems: resolver.minItems,
+        maxItems: resolver.maxItems,
+        items: isResolverRef(resolver.items) ? resolver.items : bindResolver(resolver.items, plugins)
+      };
+      if (resolver.definitions)
+        bound.definitions = bindDefinitions(resolver.definitions, plugins);
+      return bound;
+    }
+    default: {
+      const imports = buildImports(plugins, resolver.importBindings);
+      const bound = {
+        type: "dynamic",
+        requireParams: resolver.requireParams,
+        requireCapabilities: resolver.requireCapabilities,
+        inputType: resolver.inputType,
+        placeholder: resolver.placeholder,
+        prompt: resolver.prompt
+      };
+      const { fetch: fetch2, tryResolveWithoutPrompt } = resolver;
+      if (fetch2)
+        bound.fetch = ({ params, search }) => fetch2({ imports, params, search });
+      if (tryResolveWithoutPrompt) {
+        bound.tryResolveWithoutPrompt = ({ params }) => tryResolveWithoutPrompt({ imports, params });
+      }
+      return bound;
+    }
+  }
+}
+function bindFields(fields, plugins) {
+  const out = {};
+  for (const [key, field] of Object.entries(fields)) {
+    out[key] = {
+      ...field,
+      resolver: isResolverRef(field.resolver) ? field.resolver : bindResolver(field.resolver, plugins)
+    };
+  }
+  return out;
+}
+function bindDefinitions(definitions, plugins) {
+  const out = {};
+  for (const [key, def] of Object.entries(definitions)) {
+    out[key] = bindResolver(def, plugins);
+  }
+  return out;
+}
+function bindFormatter(formatter, plugins) {
+  const imports = buildImports(plugins, formatter.importBindings);
+  const bound = { format: formatter.format };
+  const { fetchContext } = formatter;
+  if (fetchContext)
+    bound.fetchContext = ({ items, input, context }) => fetchContext({ imports, items, input, context });
+  return bound;
+}
+function bindAttachments(descriptors, context) {
+  const plugins = context.plugins;
+  for (const [id, descriptor] of descriptors) {
+    if (descriptor.pluginType !== "method") continue;
+    const entry = plugins[id];
+    if (!entry || entry.pluginType !== "method") continue;
+    if (descriptor.resolvers) {
+      const bound = {};
+      for (const [param, resolver] of Object.entries(descriptor.resolvers)) {
+        bound[param] = bindResolver(resolver, plugins);
+      }
+      entry.resolvers = bound;
+    }
+    if (descriptor.formatter) {
+      entry.formatter = bindFormatter(descriptor.formatter, plugins);
+    }
+  }
+}
+function runLegacyPass(descriptors, context) {
+  const plugins = context.plugins;
+  const compatView = new Proxy(
+    {},
+    {
+      get: (_target, prop) => {
+        if (prop === "context") return context;
+        const entry = plugins[prop];
+        return entry?.value;
+      }
+    }
+  );
+  for (const id of topoOrder(descriptors)) {
+    const descriptor = descriptors.get(id);
+    if (!descriptor || descriptor.pluginType !== "legacy") continue;
+    const { rootKeys, meta, hooks, contextRest } = splitPluginContribution(
+      descriptor.run(compatView)
+    );
+    Object.assign(context.meta, meta);
+    Object.assign(context, contextRest);
+    context.hooks = buildHooks(context.hooks, hooks);
+    const exports = mirrorLegacyRootKeys(context, rootKeys, meta);
+    if (!("getRegistry" in exports)) {
+      let getRegistry2 = function(options) {
+        const sdk = this ?? exports;
+        const meta2 = {};
+        const formatters = {};
+        for (const [binding, id2] of Object.entries(context.surface)) {
+          const entry = context.plugins[id2];
+          if (!entry || entry.pluginType === "aggregate") continue;
+          const m = pluginEntryMeta(entry);
+          if (m) meta2[binding] = m;
+          const f = normalizeFormatter(entry, sdk);
+          if (f) formatters[binding] = f;
+        }
+        Object.assign(meta2, context.meta);
+        return buildRegistry({
+          sdk,
+          meta: meta2,
+          formatters,
+          packageFilter: options?.package
+        });
+      };
+      exports.getRegistry = getRegistry2;
+      plugins.getRegistry = {
+        pluginType: "method",
+        name: "getRegistry",
+        value: getRegistry2,
+        chain: []
+      };
+    }
+    plugins[id] = { pluginType: "aggregate", name: descriptor.name, exports };
+  }
+}
+function buildMethodEntries(descriptors, context, states) {
+  const plugins = context.plugins;
+  for (const [id, descriptor] of descriptors) {
+    if (descriptor.pluginType !== "method") continue;
+    const out = normalizeOutput(descriptor.output);
+    const entry = {
+      pluginType: "method",
+      name: descriptor.name,
+      chain: [],
+      inputSchema: descriptor.inputSchema,
+      // Derive the presentation type from the output mode when the author did
+      // not set one; an explicit meta.type (e.g. "create") still wins.
+      meta: out.type === "raw" || descriptor.meta?.type ? descriptor.meta : { ...descriptor.meta, type: out.type },
+      output: out,
+      // Replaced below; never called.
+      value: () => void 0
+    };
+    const callRun = (input) => descriptor.run({
+      imports: buildImports(plugins, descriptor.importBindings),
+      state: states.get(id),
+      input
+    });
+    const fold = (coreFn) => (input) => {
+      let next = coreFn;
+      for (const wrap of entry.chain) {
+        const inner = next;
+        next = (i) => wrap.run({
+          imports: buildImports(plugins, wrap.owner.importBindings),
+          next: inner,
+          input: i
+        });
+      }
+      return next(input);
+    };
+    const sdk = { context };
+    if (out.type === "list") {
+      entry.value = createPaginatedFunction(
+        fold(callRun),
+        {
+          sdk,
+          schema: descriptor.inputSchema,
+          name: descriptor.name,
+          defaultPageSize: out.defaultPageSize,
+          adaptPage: out.adaptPage
+        }
+      );
+    } else if (out.type === "item") {
+      const itemCore = async (input) => ({
+        data: await callRun(input)
+      });
+      entry.value = createFunction(
+        fold(itemCore),
+        { sdk, schema: descriptor.inputSchema, name: descriptor.name }
+      );
+    } else {
+      entry.value = (rawInput) => {
+        const input = descriptor.inputSchema ? descriptor.inputSchema.parse(rawInput) : rawInput;
+        return fold(callRun)(input);
+      };
+    }
+    if (descriptor.positional) {
+      const names = descriptor.positional;
+      const canonicalValue = entry.value;
+      entry.value = (...args) => {
+        const packed = {};
+        names.forEach((name, i) => {
+          if (i < args.length) packed[name] = args[i];
+        });
+        return canonicalValue(packed);
+      };
+      entry.positional = names;
+    }
+    plugins[id] = entry;
+  }
+}
+function buildEagerArtifacts(descriptors, context, states) {
+  const plugins = context.plugins;
+  const built = /* @__PURE__ */ new Set();
+  const building = /* @__PURE__ */ new Set();
+  const ensureBuilt = (id) => {
+    if (built.has(id)) return;
+    const descriptor = descriptors.get(id);
+    if (!descriptor || descriptor.pluginType === "aggregate" || descriptor.pluginType === "legacy") {
+      built.add(id);
+      return;
+    }
+    if (building.has(id)) {
+      throw new Error(`createSdk: dependency cycle at "${id}".`);
+    }
+    building.add(id);
+    for (const { id: depId } of descriptor.importBindings) ensureBuilt(depId);
+    if (descriptor.pluginType === "method") {
+      states.set(
+        id,
+        descriptor.setup ? descriptor.setup({
+          imports: buildImports(plugins, descriptor.importBindings)
+        }) : void 0
+      );
+    } else {
+      states.set(
+        id,
+        descriptor.setup ? descriptor.setup({
+          imports: buildImports(plugins, descriptor.importBindings)
+        }) : void 0
+      );
+      if (descriptor.privileged) {
+        plugins[id] = {
+          pluginType: "property",
+          name: descriptor.name,
+          value: context,
+          meta: descriptor.meta
+        };
+      } else if (descriptor.get) {
+        const get = descriptor.get;
+        const importBindings = descriptor.importBindings;
+        plugins[id] = {
+          pluginType: "property",
+          name: descriptor.name,
+          getValue: () => get({
+            imports: buildImports(plugins, importBindings),
+            state: states.get(id)
+          }),
+          meta: descriptor.meta
+        };
+      } else {
+        plugins[id] = {
+          pluginType: "property",
+          name: descriptor.name,
+          value: descriptor.value,
+          meta: descriptor.meta
+        };
+      }
+    }
+    building.delete(id);
+    built.add(id);
+  };
+  for (const id of descriptors.keys()) ensureBuilt(id);
+}
+function resolveAggregates(descriptors, context) {
+  const plugins = context.plugins;
+  for (const [id, descriptor] of descriptors) {
+    if (descriptor.pluginType !== "aggregate") continue;
+    const exports = {};
+    for (const [binding, child] of Object.entries(descriptor.exports)) {
+      bindValue(exports, binding, plugins[child.id]);
+    }
+    plugins[id] = { pluginType: "aggregate", name: descriptor.name, exports };
+  }
+}
+function assembleMiddleware(descriptors, context) {
+  const plugins = context.plugins;
+  for (const id of topoOrder(descriptors)) {
+    const descriptor = descriptors.get(id);
+    if (!descriptor || descriptor.pluginType !== "aggregate" || !descriptor.middleware) {
+      continue;
+    }
+    for (const [targetBinding, fn] of Object.entries(descriptor.middleware)) {
+      const edge = descriptor.importBindings.find(
+        (b) => b.binding === targetBinding
+      );
+      if (!edge) {
+        throw new Error(
+          `createSdk: middleware target "${targetBinding}" in plugin "${id}" is not a direct dependency. A middleware target must be a declared dependency of the wrapping plugin.`
+        );
+      }
+      const target = plugins[edge.id];
+      if (!target || target.pluginType !== "method") {
+        throw new Error(
+          `createSdk: middleware target "${targetBinding}" in plugin "${id}" does not resolve to a method.`
+        );
+      }
+      if (target.output?.type === "list") {
+        throw new Error(
+          `createSdk: middleware target "${targetBinding}" in plugin "${id}" resolves to a list-output method, which does not support middleware yet.`
+        );
+      }
+      target.chain.push({ run: fn, owner: descriptor });
+    }
+  }
+}
+function createSdk(root) {
+  const context = { plugins: {}, meta: {}, hooks: {}, surface: {} };
+  if (root.pluginType === "legacy-merge") {
+    const { legacy, plugin } = root;
+    const collectRoot = {
+      pluginType: "aggregate",
+      name: root.name,
+      id: `${root.id}:merge`,
+      imports: [legacy, plugin],
+      importBindings: [],
+      exports: {}
+    };
+    const plugins2 = materialize(collectPlugins(collectRoot), context);
+    const legacyExports = plugins2[legacy.id].exports;
+    let pluginSurface;
+    if (plugin.pluginType === "aggregate") {
+      pluginSurface = plugins2[plugin.id].exports;
+    } else {
+      pluginSurface = {};
+      bindValue(pluginSurface, plugin.name, plugins2[plugin.id]);
+    }
+    for (const key of Object.keys(legacyExports)) context.surface[key] = key;
+    if (plugin.pluginType === "aggregate") {
+      recordExportSurface(context, plugin.exports);
+    } else {
+      context.surface[plugin.name] = plugin.id;
+    }
+    return buildSurface(context, legacyExports, pluginSurface);
+  }
+  const plugins = materialize(collectPlugins(root), context);
+  if (root.pluginType === "method" || root.pluginType === "property") {
+    context.surface[root.name] = root.id;
+    const sdk = buildSurface(context);
+    bindValue(sdk, root.name, plugins[root.id]);
+    return sdk;
+  }
+  if (root.pluginType === "aggregate")
+    recordExportSurface(context, root.exports);
+  return buildSurface(context, plugins[root.id].exports);
+}
+function addModelPlugin(sdk, plugin, options = {}) {
+  const override = options.override === true;
+  const context = getContext(sdk);
+  const surfaceKeys = plugin.pluginType === "aggregate" ? Object.keys(plugin.exports) : [plugin.name];
+  checkRootKeyCollisions(sdk, surfaceKeys, override, "addPlugin");
+  const materialized = new Set(Object.keys(context.plugins));
+  if (override && materialized.has(plugin.id)) {
+    throw new Error(
+      `addPlugin: cannot override already-materialized plugin "${plugin.id}" on the incremental path. Rebuild the SDK with the replacement via createSdk.`
+    );
+  }
+  materialize(collectPlugins(plugin, materialized), context);
+  const entry = context.plugins[plugin.id];
+  if (entry.pluginType === "aggregate") {
+    Object.defineProperties(
+      sdk,
+      Object.getOwnPropertyDescriptors(entry.exports)
+    );
+    for (const [binding, child] of Object.entries(
+      plugin.exports
+    )) {
+      context.surface[binding] = child.id;
+    }
+  } else {
+    bindValue(sdk, plugin.name, entry);
+    context.surface[plugin.name] = plugin.id;
+  }
+}
+function addPlugin(sdk, plugin, options) {
+  if (typeof plugin === "function") {
+    const record = sdk;
+    const contribution = applyPluginToSdk(
+      record,
+      plugin,
+      options ?? {}
+    );
+    const context = record[CONTEXT];
+    if (context) {
+      mirrorLegacyRootKeys(context, contribution.rootKeys, contribution.meta);
+      for (const name of Object.keys(contribution.rootKeys)) {
+        context.surface[name] = name;
+      }
+    }
+    return;
+  }
+  addModelPlugin(
+    sdk,
+    plugin,
+    options ?? {}
+  );
 }
 function createCorePlugin(options) {
   return () => ({
@@ -1280,6 +2138,66 @@ var zapierCorePlugin = createCorePlugin({
 function createZapierCoreStack() {
   return createPluginStack().use(zapierCorePlugin);
 }
+var GetProfileSchema = z.object({}).optional().describe("Get current user's profile information");
+var UserProfileItemSchema = z.object({
+  id: z.string(),
+  first_name: z.string(),
+  last_name: z.string(),
+  full_name: z.string(),
+  email: z.string(),
+  email_confirmed: z.boolean(),
+  timezone: z.string()
+});
+
+// src/formatters/userProfile.ts
+var userProfileItemFormatter = defineFormatter({
+  format: ({
+    item
+  }) => {
+    const details = [];
+    if (item.email) {
+      details.push({ text: item.email, style: "dim" });
+    }
+    if (item.timezone) {
+      details.push({
+        text: `Timezone: ${item.timezone}`,
+        style: "accent"
+      });
+    }
+    return {
+      title: item.full_name,
+      hint: item.id,
+      details
+    };
+  }
+});
+
+// src/plugins/getProfile/index.ts
+var getProfilePlugin = defineMethod({
+  name: "getProfile",
+  imports: [dangerousContextPlugin],
+  inputSchema: GetProfileSchema,
+  output: "item",
+  formatter: userProfileItemFormatter,
+  categories: ["account"],
+  itemType: "Profile",
+  outputSchema: UserProfileItemSchema,
+  run: async ({ imports }) => {
+    const api = imports.context.api;
+    const profile = await api.get("/zapier/api/v4/profile/", {
+      authRequired: true
+    });
+    return {
+      id: String(profile.public_id ?? profile.id),
+      first_name: profile.first_name,
+      last_name: profile.last_name,
+      full_name: `${profile.first_name} ${profile.last_name}`,
+      email: profile.email,
+      email_confirmed: profile.email_confirmed,
+      timezone: profile.timezone
+    };
+  }
+});
 
 // src/constants.ts
 var ZAPIER_BASE_URL = globalThis.process?.env?.ZAPIER_BASE_URL || "https://zapier.com";
@@ -3400,8 +4318,63 @@ function parseApprovalReviewStreamPayload(parsed, toolNames) {
   }
 }
 
+// src/api/deprecation.ts
+var DEPRECATION_MESSAGE_HEADER = "zapier-sdk-deprecation-message";
+var DEPRECATION_ID_HEADER = "zapier-sdk-deprecation-id";
+var DEPRECATION_NOTICE_EVENT = "api:deprecation_notice";
+var displayedNoticeIds = /* @__PURE__ */ new Set();
+function handleDeprecationNotice({
+  response,
+  canSendDeprecationMessaging,
+  onEvent
+}) {
+  try {
+    sniffDeprecationNotice({ response, canSendDeprecationMessaging, onEvent });
+  } catch {
+  }
+}
+function sniffDeprecationNotice({
+  response,
+  canSendDeprecationMessaging,
+  onEvent
+}) {
+  if (!canSendDeprecationMessaging) return;
+  const message = response.headers?.get(DEPRECATION_MESSAGE_HEADER);
+  if (!message) return;
+  const id = response.headers.get(DEPRECATION_ID_HEADER) ?? message;
+  if (!displayedNoticeIds.has(id)) {
+    displayedNoticeIds.add(id);
+    console.warn(`[zapier-sdk] Deprecation: ${message}`);
+  }
+  if (onEvent) {
+    const payload = { id, message };
+    const deprecation = parseDeprecationDate(
+      response.headers.get("deprecation")
+    );
+    if (deprecation !== void 0) payload.deprecation = deprecation;
+    const maybePromise = onEvent({
+      type: DEPRECATION_NOTICE_EVENT,
+      payload: { ...payload },
+      timestamp: Date.now()
+    });
+    if (isPromiseLike(maybePromise)) {
+      void Promise.resolve(maybePromise).catch(() => {
+      });
+    }
+  }
+}
+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());
+  if (!match) return void 0;
+  return Number(match[1]) * 1e3;
+}
+
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.77.2" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.79.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -3513,6 +4486,30 @@ var PollApprovalResponseSchema = z.object({
   reason: z.string().optional()
 });
 var APPROVAL_MAX_POLLING_INTERVAL_MS = 5e3;
+function validateSdkPath(path) {
+  if (!path.startsWith("/") || path.startsWith("//")) {
+    throw new ZapierValidationError(
+      `fetch expects a path starting with a single '/', got: ${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");
@@ -3557,8 +4554,18 @@ var pathConfig = {
   // e.g. /relay -> https://sdkapi.zapier.com/api/v0/sdk/relay/...
   "/relay": {
     authHeader: "X-Relay-Authorization",
-    pathPrefix: "/api/v0/sdk/relay"
+    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",
@@ -3707,17 +4714,50 @@ var ZapierApiClient = class {
      * parallelism into the queue.
      */
     this.rawFetch = async (path, init) => {
-      if (!path.startsWith("/")) {
-        throw new ZapierValidationError(
-          `fetch expects a path starting with '/', got: ${path}`
-        );
-      }
+      validateSdkPath(path);
       const { url, pathConfig: pathConfig2 } = this.buildUrl(path, init?.searchParams);
       return this.withSemaphore(
         { url, method: init?.method ?? "GET", signal: init?.signal },
         () => this.rawFetchUrl(url, init, pathConfig2)
       );
     };
+    this.runApprovalFetchLoop = async ({
+      path,
+      init,
+      maxRetries,
+      approvalMode,
+      approvalContext
+    }) => {
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        const response = await this.rawFetch(path, init);
+        if (response.status !== 403) {
+          return { response };
+        }
+        const errorType = response.headers.get("x-zapier-error-type");
+        if (errorType !== "approval_required") {
+          return { response };
+        }
+        if (attempt === maxRetries) {
+          return { response };
+        }
+        if (approvalMode === "disabled") {
+          return { response };
+        }
+        if (!approvalContext) {
+          return { response };
+        }
+        try {
+          await this.runOneApprovalRound(
+            approvalContext,
+            approvalMode,
+            init?.signal ?? void 0
+          );
+        } catch (error) {
+          return { response, approvalRoundError: error };
+        }
+      }
+      throw new ZapierApiError("Approval retry loop ended unexpectedly");
+    };
     /**
      * Approval-aware HTTP fetch.
      *
@@ -3747,46 +4787,62 @@ var ZapierApiClient = class {
      * `max_retries_exceeded` instead.
      */
     this.fetch = async (path, init) => {
+      validateSdkPath(path);
       const maxRetries = this.options.maxApprovalRetries ?? DEFAULT_MAX_APPROVAL_RETRIES;
-      for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        const response = await this.rawFetch(path, init);
-        if (response.status !== 403) return response;
-        const errorType = response.headers.get("x-zapier-error-type");
-        if (errorType === "request_denied_by_policy") {
-          const { data } = await this.parseResult(response);
-          const { message, errors } = this.parseErrorResponse({
-            status: response.status,
-            statusText: response.statusText,
-            data
-          });
-          throw new ZapierApprovalError(
-            message || "Request explicitly denied by policy",
-            {
-              status: "policy_denied",
-              statusCode: response.status,
-              errors
-            }
-          );
-        }
-        if (errorType !== "approval_required") return response;
-        if (attempt === maxRetries) break;
-        const mode = this.options.approvalMode ?? getZapierApprovalMode() ?? getZapierDefaultApprovalMode();
-        if (mode === "disabled") {
-          throw new ZapierApprovalError(
-            "Approvals are disabled. Set approvalMode to 'poll' or 'throw' (or ZAPIER_APPROVAL_MODE) to enable.",
-            { status: "approval_required" }
-          );
-        }
-        if (!init?.approvalContext) {
-          throw new ZapierApiError(
-            `Received 403 approval_required for ${path}, but the caller did not provide an approvalContext builder. Every approval-capable request must pass approvalContext so the SDK can create the approval with the correct policy context.`,
-            { statusCode: 403 }
-          );
-        }
-        await this.runOneApprovalRound(
-          init.approvalContext,
-          mode,
-          init.signal ?? void 0
+      const { canSendDeprecationMessaging } = this.buildUrl(
+        path,
+        init?.searchParams
+      );
+      const approvalMode = this.options.approvalMode ?? getZapierApprovalMode() ?? getZapierDefaultApprovalMode();
+      const approvalContext = init?.approvalContext;
+      const { response, approvalRoundError } = await this.runApprovalFetchLoop({
+        path,
+        init,
+        maxRetries,
+        approvalMode,
+        approvalContext
+      });
+      handleDeprecationNotice({
+        response,
+        canSendDeprecationMessaging,
+        onEvent: this.options.onEvent
+      });
+      if (response.status !== 403) {
+        return response;
+      }
+      const errorType = response.headers.get("x-zapier-error-type");
+      if (errorType === "request_denied_by_policy") {
+        const { data } = await this.parseResult(response);
+        const { message, errors } = this.parseErrorResponse({
+          status: response.status,
+          statusText: response.statusText,
+          data
+        });
+        throw new ZapierApprovalError(
+          message || "Request explicitly denied by policy",
+          {
+            status: "policy_denied",
+            statusCode: response.status,
+            errors
+          }
+        );
+      }
+      if (errorType !== "approval_required") {
+        return response;
+      }
+      if (approvalRoundError) {
+        throw approvalRoundError;
+      }
+      if (approvalMode === "disabled") {
+        throw new ZapierApprovalError(
+          "Approvals are disabled. Set approvalMode to 'poll' or 'throw' (or ZAPIER_APPROVAL_MODE) to enable.",
+          { status: "approval_required" }
+        );
+      }
+      if (!approvalContext) {
+        throw new ZapierApiError(
+          `Received 403 approval_required for ${path}, but the caller did not provide an approvalContext builder. Every approval-capable request must pass approvalContext so the SDK can create the approval with the correct policy context.`,
+          { statusCode: 403 }
         );
       }
       throw new ZapierApprovalError(
@@ -4048,40 +5104,60 @@ var ZapierApiClient = class {
   }
   // Apply any special routing logic for configured paths.
   applyPathConfiguration(path) {
-    const matchingPathKey = Object.keys(pathConfig).find(
-      (configPath) => path === configPath || path.startsWith(configPath + "/")
-    );
-    const config = matchingPathKey ? pathConfig[matchingPathKey] : void 0;
+    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 (config && "pathPrefix" in config && config.pathPrefix && matchingPathKey) {
-      const pathWithoutPrefix = path.slice(matchingPathKey.length) || "/";
-      finalPath = `${config.pathPrefix}${pathWithoutPrefix}`;
+    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 finalBaseUrl = `https://sdkapi.${originalBaseUrl.hostname}`;
-      return {
-        url: new URL(finalPath, finalBaseUrl),
-        pathConfig: config
-      };
+      const url2 = new URL(finalPath, finalBaseUrl);
+      return buildResult(url2);
     }
     const baseUrl = new URL(this.options.baseUrl);
     const basePath = baseUrl.pathname.replace(/\/$/, "");
-    return {
-      url: new URL(basePath + finalPath, baseUrl.origin),
-      pathConfig: config
-    };
+    const url = new URL(basePath + finalPath, baseUrl.origin);
+    return buildResult(url);
   }
   // Helper to build full URLs and return routing info
   buildUrl(path, searchParams) {
-    const { url, pathConfig: config } = this.applyPathConfiguration(path);
+    const {
+      url,
+      pathConfig: config,
+      canSendDeprecationMessaging
+    } = this.applyPathConfiguration(path);
     if (searchParams) {
       Object.entries(searchParams).forEach(([key, value]) => {
         url.searchParams.set(key, value);
       });
     }
-    return { url: url.toString(), pathConfig: config };
+    return {
+      url: url.toString(),
+      pathConfig: config,
+      canSendDeprecationMessaging
+    };
   }
   // Helper to build headers
   async buildHeaders(options = {}, pathConfig2) {
@@ -4645,67 +5721,6 @@ var apiPlugin = definePlugin(
     };
   }
 );
-var GetProfileSchema = z.object({}).optional().describe("Get current user's profile information");
-var UserProfileItemSchema = z.object({
-  id: z.string(),
-  first_name: z.string(),
-  last_name: z.string(),
-  full_name: z.string(),
-  email: z.string(),
-  email_confirmed: z.boolean(),
-  timezone: z.string()
-});
-
-// src/formatters/userProfile.ts
-var userProfileItemFormatter = {
-  format: (item) => {
-    const details = [];
-    if (item.email) {
-      details.push({ text: item.email, style: "dim" });
-    }
-    if (item.timezone) {
-      details.push({
-        text: `Timezone: ${item.timezone}`,
-        style: "accent"
-      });
-    }
-    return {
-      title: item.full_name,
-      id: item.id,
-      details
-    };
-  }
-};
-
-// src/plugins/getProfile/index.ts
-var getProfilePlugin = definePlugin(
-  (sdk) => createPluginMethod(sdk, {
-    name: "getProfile",
-    categories: ["account"],
-    type: "item",
-    itemType: "Profile",
-    inputSchema: GetProfileSchema,
-    outputSchema: UserProfileItemSchema,
-    formatter: userProfileItemFormatter,
-    handler: async ({ sdk: sdk2 }) => {
-      const profile = await sdk2.context.api.get(
-        "/zapier/api/v4/profile/",
-        { authRequired: true }
-      );
-      return {
-        data: {
-          id: String(profile.public_id ?? profile.id),
-          first_name: profile.first_name,
-          last_name: profile.last_name,
-          full_name: `${profile.first_name} ${profile.last_name}`,
-          email: profile.email,
-          email_confirmed: profile.email_confirmed,
-          timezone: profile.timezone
-        }
-      };
-    }
-  })
-);
 
 // src/utils/pagination.ts
 function extractCursorFromUrl(url) {
@@ -6380,7 +7395,7 @@ var actionResultItemFormatter = {
       id: getStringProperty(obj, "id"),
       key: getStringProperty(obj, "key"),
       description: getStringProperty(obj, "description"),
-      data: item,
+      raw: item,
       details: []
     };
   }
@@ -10152,12 +11167,6 @@ var eventEmissionPlugin = definePlugin(
 function createOptionsPlugin(options) {
   return () => ({ context: { options } });
 }
-function createSdk() {
-  logDeprecation2(
-    "createSdk() is deprecated. Build SDKs with createPluginStack().use(...).toSdk() instead. The chain pattern shares plugin closures (and their state) across derived SDKs in ways that are rarely what callers expect; stacks produce fresh closures per .toSdk() call."
-  );
-  return withDeprecatedAddPlugin(createZapierCoreStack().toSdk());
-}
 function createZapierSdkWithoutRegistry(options = {}) {
   logDeprecation2(
     "createZapierSdkWithoutRegistry is deprecated; use createZapierSdk instead. getRegistry is now available on every sdk."
@@ -10165,10 +11174,22 @@ function createZapierSdkWithoutRegistry(options = {}) {
   return createZapierSdk(options);
 }
 function createZapierSdkStack(options = {}) {
-  return createZapierCoreStack().use(createOptionsPlugin(options)).use(eventEmissionPlugin).use(apiPlugin).use(manifestPlugin).use(capabilitiesPlugin).use(connectionsPlugin).use(listAppsPlugin).use(getAppPlugin).use(listConnectionsPlugin).use(getConnectionPlugin).use(findFirstConnectionPlugin).use(findUniqueConnectionPlugin).use(getConnectionStartUrlPlugin).use(waitForNewConnectionPlugin).use(createConnectionPlugin).use(listActionsPlugin).use(getActionPlugin).use(listActionInputFieldsPlugin).use(getActionInputFieldsSchemaPlugin).use(listActionInputFieldChoicesPlugin).use(listInputFieldsDeprecatedPlugin).use(getInputFieldsSchemaDeprecatedPlugin).use(listInputFieldChoicesDeprecatedPlugin).use(runActionPlugin).use(listAuthenticationsPlugin).use(getAuthenticationPlugin).use(findFirstAuthenticationPlugin).use(findUniqueAuthenticationPlugin).use(listClientCredentialsPlugin).use(createClientCredentialsPlugin).use(deleteClientCredentialsPlugin).use(fetchPlugin).use(requestPlugin).use(listTablesPlugin).use(getTablePlugin).use(deleteTablePlugin).use(createTablePlugin).use(listTableFieldsPlugin).use(createTableFieldsPlugin).use(deleteTableFieldsPlugin).use(listTableRecordsPlugin).use(getTableRecordPlugin).use(createTableRecordsPlugin).use(deleteTableRecordsPlugin).use(updateTableRecordsPlugin).use(appsPlugin).use(getProfilePlugin);
+  return createZapierCoreStack().use(createOptionsPlugin(options)).use(eventEmissionPlugin).use(apiPlugin).use(manifestPlugin).use(capabilitiesPlugin).use(connectionsPlugin).use(listAppsPlugin).use(getAppPlugin).use(listConnectionsPlugin).use(getConnectionPlugin).use(findFirstConnectionPlugin).use(findUniqueConnectionPlugin).use(getConnectionStartUrlPlugin).use(waitForNewConnectionPlugin).use(createConnectionPlugin).use(listActionsPlugin).use(getActionPlugin).use(listActionInputFieldsPlugin).use(getActionInputFieldsSchemaPlugin).use(listActionInputFieldChoicesPlugin).use(listInputFieldsDeprecatedPlugin).use(getInputFieldsSchemaDeprecatedPlugin).use(listInputFieldChoicesDeprecatedPlugin).use(runActionPlugin).use(listAuthenticationsPlugin).use(getAuthenticationPlugin).use(findFirstAuthenticationPlugin).use(findUniqueAuthenticationPlugin).use(listClientCredentialsPlugin).use(createClientCredentialsPlugin).use(deleteClientCredentialsPlugin).use(fetchPlugin).use(requestPlugin).use(listTablesPlugin).use(getTablePlugin).use(deleteTablePlugin).use(createTablePlugin).use(listTableFieldsPlugin).use(createTableFieldsPlugin).use(deleteTableFieldsPlugin).use(listTableRecordsPlugin).use(getTableRecordPlugin).use(createTableRecordsPlugin).use(deleteTableRecordsPlugin).use(updateTableRecordsPlugin).use(appsPlugin);
 }
+var zapierSdkPlugin = definePlugin({
+  namespace: "zapier",
+  name: "sdk",
+  exports: [getProfilePlugin]
+});
 function createZapierSdk(options = {}) {
-  return withDeprecatedAddPlugin(createZapierSdkStack(options).toSdk());
+  return createSdk(
+    defineLegacyMerge({
+      namespace: "zapier",
+      name: "sdk-stack-merge",
+      legacy: createZapierSdkStack(options).toPlugin(),
+      plugin: zapierSdkPlugin
+    })
+  );
 }
 var TriggerInboxStatusSchema = z.union([
   z.enum([
@@ -13308,10 +14329,17 @@ var registryPlugin = definePlugin((_sdk) => {
 
 // src/experimental.ts
 function createZapierSdkStack2(options = {}) {
-  return createZapierCoreStack().use(createOptionsPlugin(options)).use(eventEmissionPlugin).use(apiPlugin).use(manifestPlugin).use(capabilitiesPlugin).use(connectionsPlugin).use(listAppsPlugin).use(getAppPlugin).use(listConnectionsPlugin).use(getConnectionPlugin).use(findFirstConnectionPlugin).use(findUniqueConnectionPlugin).use(getConnectionStartUrlPlugin).use(waitForNewConnectionPlugin).use(createConnectionPlugin).use(listActionsPlugin).use(getActionPlugin).use(listActionInputFieldsPlugin).use(getActionInputFieldsSchemaPlugin).use(listActionInputFieldChoicesPlugin).use(listInputFieldsDeprecatedPlugin).use(getInputFieldsSchemaDeprecatedPlugin).use(listInputFieldChoicesDeprecatedPlugin).use(runActionPlugin).use(listAuthenticationsPlugin).use(getAuthenticationPlugin).use(findFirstAuthenticationPlugin).use(findUniqueAuthenticationPlugin).use(listClientCredentialsPlugin).use(createClientCredentialsPlugin).use(deleteClientCredentialsPlugin).use(fetchPlugin).use(requestPlugin).use(listTriggerInboxesPlugin).use(createTriggerInboxPlugin).use(ensureTriggerInboxPlugin).use(getTriggerInboxPlugin).use(updateTriggerInboxPlugin).use(deleteTriggerInboxPlugin).use(pauseTriggerInboxPlugin).use(resumeTriggerInboxPlugin).use(listTriggerInboxMessagesPlugin).use(leaseTriggerInboxMessagesPlugin).use(ackTriggerInboxMessagesPlugin).use(releaseTriggerInboxMessagesPlugin).use(drainTriggerInboxPlugin).use(watchTriggerInboxPlugin).use(listTriggersPlugin).use(listTriggerInputFieldsPlugin).use(listTriggerInputFieldChoicesPlugin).use(getTriggerInputFieldsSchemaPlugin).use(listTablesPlugin).use(getTablePlugin).use(deleteTablePlugin).use(createTablePlugin).use(listTableFieldsPlugin).use(createTableFieldsPlugin).use(deleteTableFieldsPlugin).use(listTableRecordsPlugin).use(getTableRecordPlugin).use(createTableRecordsPlugin).use(deleteTableRecordsPlugin).use(updateTableRecordsPlugin).use(listWorkflowsPlugin).use(getWorkflowPlugin).use(createWorkflowPlugin).use(updateWorkflowPlugin).use(enableWorkflowPlugin).use(disableWorkflowPlugin).use(deleteWorkflowPlugin).use(listDurableRunsPlugin).use(getDurableRunPlugin).use(runDurablePlugin).use(cancelDurableRunPlugin).use(publishWorkflowVersionPlugin).use(listWorkflowVersionsPlugin).use(getWorkflowVersionPlugin).use(listWorkflowRunsPlugin).use(getWorkflowRunPlugin).use(getTriggerRunPlugin).use(triggerWorkflowPlugin).use(appsPlugin).use(getProfilePlugin);
+  return createZapierCoreStack().use(createOptionsPlugin(options)).use(eventEmissionPlugin).use(apiPlugin).use(manifestPlugin).use(capabilitiesPlugin).use(connectionsPlugin).use(listAppsPlugin).use(getAppPlugin).use(listConnectionsPlugin).use(getConnectionPlugin).use(findFirstConnectionPlugin).use(findUniqueConnectionPlugin).use(getConnectionStartUrlPlugin).use(waitForNewConnectionPlugin).use(createConnectionPlugin).use(listActionsPlugin).use(getActionPlugin).use(listActionInputFieldsPlugin).use(getActionInputFieldsSchemaPlugin).use(listActionInputFieldChoicesPlugin).use(listInputFieldsDeprecatedPlugin).use(getInputFieldsSchemaDeprecatedPlugin).use(listInputFieldChoicesDeprecatedPlugin).use(runActionPlugin).use(listAuthenticationsPlugin).use(getAuthenticationPlugin).use(findFirstAuthenticationPlugin).use(findUniqueAuthenticationPlugin).use(listClientCredentialsPlugin).use(createClientCredentialsPlugin).use(deleteClientCredentialsPlugin).use(fetchPlugin).use(requestPlugin).use(listTriggerInboxesPlugin).use(createTriggerInboxPlugin).use(ensureTriggerInboxPlugin).use(getTriggerInboxPlugin).use(updateTriggerInboxPlugin).use(deleteTriggerInboxPlugin).use(pauseTriggerInboxPlugin).use(resumeTriggerInboxPlugin).use(listTriggerInboxMessagesPlugin).use(leaseTriggerInboxMessagesPlugin).use(ackTriggerInboxMessagesPlugin).use(releaseTriggerInboxMessagesPlugin).use(drainTriggerInboxPlugin).use(watchTriggerInboxPlugin).use(listTriggersPlugin).use(listTriggerInputFieldsPlugin).use(listTriggerInputFieldChoicesPlugin).use(getTriggerInputFieldsSchemaPlugin).use(listTablesPlugin).use(getTablePlugin).use(deleteTablePlugin).use(createTablePlugin).use(listTableFieldsPlugin).use(createTableFieldsPlugin).use(deleteTableFieldsPlugin).use(listTableRecordsPlugin).use(getTableRecordPlugin).use(createTableRecordsPlugin).use(deleteTableRecordsPlugin).use(updateTableRecordsPlugin).use(listWorkflowsPlugin).use(getWorkflowPlugin).use(createWorkflowPlugin).use(updateWorkflowPlugin).use(enableWorkflowPlugin).use(disableWorkflowPlugin).use(deleteWorkflowPlugin).use(listDurableRunsPlugin).use(getDurableRunPlugin).use(runDurablePlugin).use(cancelDurableRunPlugin).use(publishWorkflowVersionPlugin).use(listWorkflowVersionsPlugin).use(getWorkflowVersionPlugin).use(listWorkflowRunsPlugin).use(getWorkflowRunPlugin).use(getTriggerRunPlugin).use(triggerWorkflowPlugin).use(appsPlugin);
 }
 function createZapierSdk2(options = {}) {
-  return withDeprecatedAddPlugin(createZapierSdkStack2(options).toSdk());
+  return createSdk(
+    defineLegacyMerge({
+      namespace: "zapier",
+      name: "experimental-stack-merge",
+      legacy: createZapierSdkStack2(options).toPlugin(),
+      plugin: zapierSdkPlugin
+    })
+  );
 }
 
-export { ActionKeyPropertySchema, ActionPropertySchema, ActionTimeoutMsPropertySchema, ActionTypePropertySchema, AppKeyPropertySchema, AppPropertySchema, AppsPropertySchema, AuthMechanism, AuthenticationIdPropertySchema, BaseSdkOptionsSchema, CONTEXT_CACHE_MAX_SIZE, CONTEXT_CACHE_TTL_MS, CORE_ERROR_SYMBOL, ClientCredentialsObjectSchema, ConnectionEntrySchema, ConnectionIdPropertySchema, ConnectionPropertySchema, ConnectionsMapSchema, ConnectionsPropertySchema, CoreErrorCode, CredentialsFunctionSchema, CredentialsObjectSchema, CredentialsSchema, DEFAULT_ACTION_TIMEOUT_MS, DEFAULT_APPROVAL_TIMEOUT_MS, DEFAULT_CONFIG_PATH, DEFAULT_MAX_APPROVAL_RETRIES, DEFAULT_PAGE_SIZE, DebugPropertySchema, FieldsPropertySchema, InputFieldPropertySchema, InputsPropertySchema, LeaseLimitPropertySchema, LeasePropertySchema, LeaseSecondsPropertySchema, LimitPropertySchema, MAX_CONCURRENCY_LIMIT, MAX_PAGE_LIMIT, OffsetPropertySchema, OutputPropertySchema, ParamsPropertySchema, PkceCredentialsObjectSchema, RecordPropertySchema, RecordsPropertySchema, RelayFetchSchema, RelayRequestSchema, ResolvedCredentialsSchema, TablePropertySchema, TablesPropertySchema, TriggerInboxNamePropertySchema, TriggerInboxPropertySchema, ZAPIER_BASE_URL, ZAPIER_MAX_CONCURRENT_REQUESTS, ZAPIER_MAX_NETWORK_RETRIES, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, ZapierAbortDrainSignal, ZapierActionError, ZapierApiError, ZapierAppNotFoundError, ZapierApprovalError, ZapierAuthenticationError, ZapierBundleError, ZapierConfigurationError, ZapierConflictError, ZapierError, ZapierNotFoundError, ZapierRateLimitError, ZapierRelayError, ZapierReleaseTriggerMessageSignal, ZapierResourceNotFoundError, ZapierSignal, ZapierTimeoutError, ZapierUnknownError, ZapierValidationError, actionKeyResolver, actionTypeResolver, addPlugin, apiPlugin, appKeyResolver, appsPlugin, connectionIdGenericResolver as authenticationIdGenericResolver, connectionIdResolver as authenticationIdResolver, batch, buildApplicationLifecycleEvent, buildCapabilityMessage, buildErrorEvent, buildErrorEventWithContext, buildMethodCalledEvent, cleanupEventListeners, clearTokenCache, clientCredentialsNameResolver, clientIdResolver, composePlugins, connectionIdGenericResolver, connectionIdResolver, connectionsPlugin, createBaseEvent, createClientCredentialsPlugin, createCorePlugin, createFunction, createMemoryCache, createOptionsPlugin, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createSdk, createTableFieldsPlugin, createTablePlugin, createTableRecordsPlugin, createZapierApi, createZapierCoreStack, createZapierSdk2 as createZapierSdk, createZapierSdkStack2 as createZapierSdkStack, createZapierSdkWithoutRegistry, definePlugin, deleteClientCredentialsPlugin, deleteTableFieldsPlugin, deleteTablePlugin, deleteTableRecordsPlugin, durableRunIdResolver, eventEmissionPlugin, fetchPlugin, findFirstConnectionPlugin, findManifestEntry, findUniqueConnectionPlugin, formatErrorMessage, generateEventId, getActionInputFieldsSchemaPlugin, getActionPlugin, getAgent, getAppPlugin, getBaseUrlFromCredentials, getCallerContext, getCiPlatform, getClientIdFromCredentials, getConnectionPlugin, getCoreErrorCause, getCoreErrorCode, getCpuTime, getCurrentTimestamp, getMemoryUsage, getOrCreateApiClient, getOsInfo, getPlatformVersions, getPreferredManifestEntryKey, getProfilePlugin, getReleaseId, getTablePlugin, getTableRecordPlugin, getTokenFromCliLogin, getTtyContext, getZapierApprovalMode, getZapierDefaultApprovalMode, getZapierOpenAutoModeApprovalsInBrowser, getZapierSdkService, injectCliLogin, inputFieldKeyResolver, inputsAllOptionalResolver, inputsResolver, invalidateCachedToken, invalidateCredentialsToken, isCi, isCliLoginAvailable, isClientCredentials, isCoreError, isCredentialsFunction, isCredentialsObject, isPermanentHttpError, isPkceCredentials, isPositional, listActionInputFieldChoicesPlugin, listActionInputFieldsPlugin, listActionsPlugin, listAppsPlugin, listClientCredentialsPlugin, listConnectionsPlugin, listTableFieldsPlugin, listTableRecordsPlugin, listTablesPlugin, logDeprecation2 as logDeprecation, manifestPlugin, parseConcurrencyEnvVar, readManifestFromFile, registryPlugin, requestPlugin, resetDeprecationWarnings2 as resetDeprecationWarnings, resolveAuth, resolveAuthToken, resolveCredentials, resolveCredentialsFromEnv, runActionPlugin, runInMethodScope, runWithCallerContext, runWithTelemetryContext, tableFieldIdsResolver, tableFieldsResolver, tableFiltersResolver, tableIdResolver, tableNameResolver, tableRecordIdResolver, tableRecordIdsResolver, tableRecordsResolver, tableSortResolver, tableUpdateRecordsResolver, toSnakeCase, toTitleCase, triggerInboxResolver, triggerMessagesResolver, updateTableRecordsPlugin, workflowIdResolver, workflowRunIdResolver, workflowVersionIdResolver, zapierAdaptError };
+export { ActionKeyPropertySchema, ActionPropertySchema, ActionTimeoutMsPropertySchema, ActionTypePropertySchema, AppKeyPropertySchema, AppPropertySchema, AppsPropertySchema, AuthMechanism, AuthenticationIdPropertySchema, BaseSdkOptionsSchema, CONTEXT_CACHE_MAX_SIZE, CONTEXT_CACHE_TTL_MS, CORE_ERROR_SYMBOL, ClientCredentialsObjectSchema, ConnectionEntrySchema, ConnectionIdPropertySchema, ConnectionPropertySchema, ConnectionsMapSchema, ConnectionsPropertySchema, CoreErrorCode, CredentialsFunctionSchema, CredentialsObjectSchema, CredentialsSchema, DEFAULT_ACTION_TIMEOUT_MS, DEFAULT_APPROVAL_TIMEOUT_MS, DEFAULT_CONFIG_PATH, DEFAULT_MAX_APPROVAL_RETRIES, DEFAULT_PAGE_SIZE, DEPRECATION_NOTICE_EVENT, DebugPropertySchema, FieldsPropertySchema, InputFieldPropertySchema, InputsPropertySchema, LeaseLimitPropertySchema, LeasePropertySchema, LeaseSecondsPropertySchema, LimitPropertySchema, MAX_CONCURRENCY_LIMIT, MAX_PAGE_LIMIT, OffsetPropertySchema, OutputPropertySchema, ParamsPropertySchema, PkceCredentialsObjectSchema, RecordPropertySchema, RecordsPropertySchema, RelayFetchSchema, RelayRequestSchema, ResolvedCredentialsSchema, TablePropertySchema, TablesPropertySchema, TriggerInboxNamePropertySchema, TriggerInboxPropertySchema, ZAPIER_BASE_URL, ZAPIER_MAX_CONCURRENT_REQUESTS, ZAPIER_MAX_NETWORK_RETRIES, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, ZapierAbortDrainSignal, ZapierActionError, ZapierApiError, ZapierAppNotFoundError, ZapierApprovalError, ZapierAuthenticationError, ZapierBundleError, ZapierConfigurationError, ZapierConflictError, ZapierError, ZapierNotFoundError, ZapierRateLimitError, ZapierRelayError, ZapierReleaseTriggerMessageSignal, ZapierResourceNotFoundError, ZapierSignal, ZapierTimeoutError, ZapierUnknownError, ZapierValidationError, actionKeyResolver, actionTypeResolver, addPlugin, apiPlugin, appKeyResolver, appsPlugin, connectionIdGenericResolver as authenticationIdGenericResolver, connectionIdResolver as authenticationIdResolver, batch, buildApplicationLifecycleEvent, buildCapabilityMessage, buildErrorEvent, buildErrorEventWithContext, buildMethodCalledEvent, cleanupEventListeners, clearTokenCache, clientCredentialsNameResolver, clientIdResolver, composePlugins, connectionIdGenericResolver, connectionIdResolver, connectionsPlugin, createBaseEvent, createClientCredentialsPlugin, createCorePlugin, createFunction, createMemoryCache, createOptionsPlugin, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createSdk, createTableFieldsPlugin, createTablePlugin, createTableRecordsPlugin, createZapierApi, createZapierCoreStack, createZapierSdk2 as createZapierSdk, createZapierSdkStack2 as createZapierSdkStack, createZapierSdkWithoutRegistry, dangerousContextPlugin, declareMethod, declareProperty, defineLegacyMerge, defineMethod, definePlugin, defineProperty, deleteClientCredentialsPlugin, deleteTableFieldsPlugin, deleteTablePlugin, deleteTableRecordsPlugin, durableRunIdResolver, eventEmissionPlugin, fetchPlugin, findFirstConnectionPlugin, findManifestEntry, findUniqueConnectionPlugin, formatErrorMessage, fromFunctionPlugin, generateEventId, getActionInputFieldsSchemaPlugin, getActionPlugin, getAgent, getAppPlugin, getBaseUrlFromCredentials, getCallerContext, getCiPlatform, getClientIdFromCredentials, getConnectionPlugin, getContext, getCoreErrorCause, getCoreErrorCode, getCpuTime, getCurrentTimestamp, getMemoryUsage, getOrCreateApiClient, getOsInfo, getPlatformVersions, getPreferredManifestEntryKey, getProfilePlugin, getReleaseId, getTablePlugin, getTableRecordPlugin, getTokenFromCliLogin, getTtyContext, getZapierApprovalMode, getZapierDefaultApprovalMode, getZapierOpenAutoModeApprovalsInBrowser, getZapierSdkService, injectCliLogin, inputFieldKeyResolver, inputsAllOptionalResolver, inputsResolver, invalidateCachedToken, invalidateCredentialsToken, isCi, isCliLoginAvailable, isClientCredentials, isCoreError, isCredentialsFunction, isCredentialsObject, isPermanentHttpError, isPkceCredentials, isPositional, listActionInputFieldChoicesPlugin, listActionInputFieldsPlugin, listActionsPlugin, listAppsPlugin, listClientCredentialsPlugin, listConnectionsPlugin, listTableFieldsPlugin, listTableRecordsPlugin, listTablesPlugin, logDeprecation2 as logDeprecation, manifestPlugin, parseConcurrencyEnvVar, readManifestFromFile, registryPlugin, requestPlugin, resetDeprecationWarnings2 as resetDeprecationWarnings, resolveAuth, resolveAuthToken, resolveCredentials, resolveCredentialsFromEnv, runActionPlugin, runInMethodScope, runWithCallerContext, runWithTelemetryContext, tableFieldIdsResolver, tableFieldsResolver, tableFiltersResolver, tableIdResolver, tableNameResolver, tableRecordIdResolver, tableRecordIdsResolver, tableRecordsResolver, tableSortResolver, tableUpdateRecordsResolver, toSnakeCase, toTitleCase, triggerInboxResolver, triggerMessagesResolver, updateTableRecordsPlugin, workflowIdResolver, workflowRunIdResolver, workflowVersionIdResolver, zapierAdaptError, zapierSdkPlugin };