@zapier/zapier-sdk 0.77.1 → 0.78.0

package/dist/experimental.cjs

@@ -52,6 +52,7 @@ function canonicalInputSchema(schema) {
 function buildRegistry({
   sdk,
   meta,
+  formatters,
   packageFilter
 }) {
   const definitionsByKey = /* @__PURE__ */ new Map();
@@ -92,7 +93,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),
@@ -518,8 +519,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 () => {
@@ -694,9 +695,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 = {
@@ -765,8 +763,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);
@@ -780,15 +777,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.`
       );
     }
   }
@@ -839,7 +849,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,
@@ -851,9 +861,6 @@ function wrapAsSdk(properties, context, opts) {
       });
     }
   };
-  if (opts?.addPlugin !== void 0) {
-    sdk.addPlugin = opts.addPlugin;
-  }
   return sdk;
 }
 function wrapAccumulatorAsSdk(acc) {
@@ -872,126 +879,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(
@@ -999,6 +972,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: zod.z.object({ package: zod.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 () => ({
@@ -1282,6 +2140,66 @@ var zapierCorePlugin = createCorePlugin({
 function createZapierCoreStack() {
   return createPluginStack().use(zapierCorePlugin);
 }
+var GetProfileSchema = zod.z.object({}).optional().describe("Get current user's profile information");
+var UserProfileItemSchema = zod.z.object({
+  id: zod.z.string(),
+  first_name: zod.z.string(),
+  last_name: zod.z.string(),
+  full_name: zod.z.string(),
+  email: zod.z.string(),
+  email_confirmed: zod.z.boolean(),
+  timezone: zod.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";
@@ -3403,7 +4321,7 @@ function parseApprovalReviewStreamPayload(parsed, toolNames) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.77.1" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.78.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -4647,67 +5565,6 @@ var apiPlugin = definePlugin(
     };
   }
 );
-var GetProfileSchema = zod.z.object({}).optional().describe("Get current user's profile information");
-var UserProfileItemSchema = zod.z.object({
-  id: zod.z.string(),
-  first_name: zod.z.string(),
-  last_name: zod.z.string(),
-  full_name: zod.z.string(),
-  email: zod.z.string(),
-  email_confirmed: zod.z.boolean(),
-  timezone: zod.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) {
@@ -6382,7 +7239,7 @@ var actionResultItemFormatter = {
       id: getStringProperty(obj, "id"),
       key: getStringProperty(obj, "key"),
       description: getStringProperty(obj, "description"),
-      data: item,
+      raw: item,
       details: []
     };
   }
@@ -10154,12 +11011,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."
@@ -10167,10 +11018,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 = zod.z.union([
   zod.z.enum([
@@ -13310,10 +14173,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
+    })
+  );
 }
 
 exports.ActionKeyPropertySchema = ActionKeyPropertySchema;
@@ -13430,7 +14300,13 @@ exports.createZapierCoreStack = createZapierCoreStack;
 exports.createZapierSdk = createZapierSdk2;
 exports.createZapierSdkStack = createZapierSdkStack2;
 exports.createZapierSdkWithoutRegistry = createZapierSdkWithoutRegistry;
+exports.dangerousContextPlugin = dangerousContextPlugin;
+exports.declareMethod = declareMethod;
+exports.declareProperty = declareProperty;
+exports.defineLegacyMerge = defineLegacyMerge;
+exports.defineMethod = defineMethod;
 exports.definePlugin = definePlugin;
+exports.defineProperty = defineProperty;
 exports.deleteClientCredentialsPlugin = deleteClientCredentialsPlugin;
 exports.deleteTableFieldsPlugin = deleteTableFieldsPlugin;
 exports.deleteTablePlugin = deleteTablePlugin;
@@ -13442,6 +14318,7 @@ exports.findFirstConnectionPlugin = findFirstConnectionPlugin;
 exports.findManifestEntry = findManifestEntry;
 exports.findUniqueConnectionPlugin = findUniqueConnectionPlugin;
 exports.formatErrorMessage = formatErrorMessage;
+exports.fromFunctionPlugin = fromFunctionPlugin;
 exports.generateEventId = generateEventId;
 exports.getActionInputFieldsSchemaPlugin = getActionInputFieldsSchemaPlugin;
 exports.getActionPlugin = getActionPlugin;
@@ -13452,6 +14329,7 @@ exports.getCallerContext = getCallerContext;
 exports.getCiPlatform = getCiPlatform;
 exports.getClientIdFromCredentials = getClientIdFromCredentials;
 exports.getConnectionPlugin = getConnectionPlugin;
+exports.getContext = getContext;
 exports.getCoreErrorCause = getCoreErrorCause;
 exports.getCoreErrorCode = getCoreErrorCode;
 exports.getCpuTime = getCpuTime;
@@ -13529,3 +14407,4 @@ exports.workflowIdResolver = workflowIdResolver;
 exports.workflowRunIdResolver = workflowRunIdResolver;
 exports.workflowVersionIdResolver = workflowVersionIdResolver;
 exports.zapierAdaptError = zapierAdaptError;
+exports.zapierSdkPlugin = zapierSdkPlugin;