@zapier/zapier-sdk 0.77.1 → 0.78.0

package/dist/index.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,419 +972,1304 @@ 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 createCorePlugin(options) {
-  return () => ({
-    context: {
-      core: options
+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 "@").`
+      );
     }
-  });
+  }
 }
-function withPositional(schema) {
-  Object.assign(schema._zod.def, {
-    positionalMeta: { positional: true }
-  });
-  return schema;
+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 schemaHasPositionalMeta(schema) {
-  return "positionalMeta" in schema._zod.def;
+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 isPositional(schema) {
-  if (schemaHasPositionalMeta(schema) && schema._zod.def.positionalMeta?.positional) {
-    return true;
+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);
+    }
   }
-  if (schema instanceof zod.z.ZodOptional) {
-    return isPositional(schema._zod.def.innerType);
+  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 } : {}
+    };
   }
-  if (schema instanceof zod.z.ZodDefault) {
-    return isPositional(schema._zod.def.innerType);
+  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;
   }
-  return false;
+  if (entry.pluginType === "property" && entry.meta) return entry.meta;
+  return void 0;
 }
-
-// src/constants.ts
-var ZAPIER_BASE_URL = globalThis.process?.env?.ZAPIER_BASE_URL || "https://zapier.com";
-function getZapierSdkService() {
-  return globalThis.process?.env?.ZAPIER_SDK_SERVICE;
+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 MAX_PAGE_LIMIT = 1e4;
-var DEFAULT_PAGE_SIZE = 100;
-var DEFAULT_ACTION_TIMEOUT_MS = 18e4;
-function parseIntEnvVar(name) {
-  const value = globalThis.process?.env?.[name];
-  if (value === void 0) return void 0;
-  const parsed = parseInt(value, 10);
-  if (isNaN(parsed)) {
-    console.warn(
-      `[zapier-sdk] Invalid value for ${name}: "${value}" (expected integer)`
-    );
-    return void 0;
+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 parsed;
+  return out;
 }
-var ZAPIER_MAX_NETWORK_RETRIES = parseIntEnvVar("ZAPIER_MAX_NETWORK_RETRIES") ?? 3;
-var ZAPIER_MAX_NETWORK_RETRY_DELAY_MS = parseIntEnvVar("ZAPIER_MAX_NETWORK_RETRY_DELAY_MS") ?? 6e4;
-var MAX_CONCURRENCY_LIMIT = 1e4;
-function parseConcurrencyEnvVar(name) {
-  const value = globalThis.process?.env?.[name];
-  if (!value) return void 0;
-  if (value === "Infinity") return Infinity;
-  if (/^[1-9]\d*$/.test(value)) {
-    const parsed = parseInt(value, 10);
-    if (parsed <= MAX_CONCURRENCY_LIMIT) return parsed;
+function resolverImportEdges(resolver) {
+  const out = [...resolver.imports];
+  for (const child of nestedResolvers(resolver)) {
+    out.push(...resolverImportEdges(child));
   }
-  console.warn(
-    `[zapier-sdk] Invalid value for ${name}: "${value}" (expected positive integer 1-${MAX_CONCURRENCY_LIMIT} or "Infinity")`
-  );
-  return void 0;
+  return out;
 }
-var ZAPIER_MAX_CONCURRENT_REQUESTS = parseConcurrencyEnvVar("ZAPIER_MAX_CONCURRENT_REQUESTS") ?? 200;
-function getZapierApprovalMode() {
-  const value = globalThis.process?.env?.ZAPIER_APPROVAL_MODE;
-  if (value === "disabled" || value === "poll" || value === "throw")
-    return value;
-  return void 0;
+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 getZapierOpenAutoModeApprovalsInBrowser() {
-  const value = globalThis.process?.env?.ZAPIER_OPEN_AUTO_MODE_APPROVALS_IN_BROWSER;
-  if (value === void 0) return void 0;
-  return value === "true";
+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 getZapierDefaultApprovalMode() {
-  const isInteractive = !!globalThis.process?.stdin?.isTTY && !!globalThis.process?.stdout?.isTTY;
-  return isInteractive ? "poll" : "throw";
+function isStandIn(plugin) {
+  return (plugin.pluginType === "method" || plugin.pluginType === "property" || plugin.pluginType === "aggregate") && plugin.standIn === true;
 }
-var DEFAULT_APPROVAL_TIMEOUT_MS = 10 * 60 * 1e3;
-var DEFAULT_MAX_APPROVAL_RETRIES = 2;
-
-// src/types/properties.ts
-var AppKeyPropertySchema = withPositional(
-  zod.z.string().min(1).describe("App key (e.g., 'SlackCLIAPI' or slug like 'github')")
-);
-var AppPropertySchema = withPositional(
-  zod.z.string().min(1).describe(
-    "App slug (e.g., 'github'), implementation name (e.g., 'SlackCLIAPI'), or versioned ID (e.g., 'github@1.2.3')"
-  )
-);
-var ActionTypePropertySchema = zod.z.enum([
-  "read",
-  "read_bulk",
-  "write",
-  "run",
-  "search",
-  "search_or_write",
-  "search_and_write",
-  "filter"
-]).describe("Action type that matches the action's defined type");
-var ActionKeyPropertySchema = zod.z.string().min(1).describe("Action key to execute");
-var ActionPropertySchema = withPositional(
-  zod.z.string().min(1).describe("Action key (e.g., 'send_message' or 'find_row')")
-);
-var InputFieldPropertySchema = withPositional(
-  zod.z.string().min(1).describe("Input field key to get choices for")
-);
-var ConnectionIdPropertySchema = zod.z.union([zod.z.string(), zod.z.number().int().positive()]).describe("Connection ID to use for this action");
-var AuthenticationIdPropertySchema = ConnectionIdPropertySchema.meta({
-  deprecated: true
-});
-var ConnectionPropertySchema = zod.z.union([zod.z.string(), zod.z.number().int().positive()]).describe(
-  "Connection alias or connection ID (UUID or positive integer). Strings that match a key in the connections map are resolved against it; otherwise the value is used as a connection ID directly."
-);
-var InputsPropertySchema = zod.z.record(zod.z.string(), zod.z.unknown()).describe("Input parameters for the action");
-var LimitPropertySchema = zod.z.number().int().min(1).max(MAX_PAGE_LIMIT).default(50).describe("Maximum number of items to return");
-var OffsetPropertySchema = zod.z.number().int().min(0).default(0).describe("Number of items to skip for pagination");
-var OutputPropertySchema = zod.z.string().describe("Output file path");
-var DebugPropertySchema = zod.z.boolean().default(false).describe("Enable debug logging");
-var ParamsPropertySchema = zod.z.record(zod.z.string(), zod.z.unknown()).describe("Additional parameters");
-var ActionTimeoutMsPropertySchema = zod.z.number().min(1e3).optional().describe(
-  `Maximum time to wait for action completion in milliseconds (default: ${DEFAULT_ACTION_TIMEOUT_MS})`
-);
-var TablePropertySchema = withPositional(
-  zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
-);
-var RecordPropertySchema = withPositional(
-  zod.z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID").describe("The unique identifier of the record")
-);
-var RecordsPropertySchema = zod.z.array(zod.z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID")).min(1).max(100).describe("Record IDs to operate on");
-var FieldsPropertySchema = zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])).describe(
-  'Fields to operate on. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
-);
-var AppsPropertySchema = zod.z.array(zod.z.string()).describe("Filter by app keys (e.g., 'SlackCLIAPI' or slug like 'github')");
-var TablesPropertySchema = zod.z.array(zod.z.string()).describe("Filter by specific table IDs");
-var ConnectionsPropertySchema = zod.z.array(zod.z.string()).describe("List of connection IDs to filter by");
-var TriggerInboxPropertySchema = withPositional(
-  zod.z.string().min(1).describe(
-    "Trigger inbox identifier \u2014 UUID or name. Non-UUID values are resolved by name via the inbox list endpoint."
-  )
-);
-var TriggerInboxNamePropertySchema = zod.z.string().min(1).max(100).describe(
-  "Inbox name; unique per (user, account). Enables get-or-create on createTriggerInbox."
-);
-var LeasePropertySchema = zod.z.string().min(1).describe("Lease ID returned from leaseTriggerInboxMessages");
-var LeaseSecondsPropertySchema = zod.z.number().int().min(1).max(3600).describe(
-  "Seconds until the lease expires; messages return to available if not acked. API default is 300 (5 minutes)."
-);
-var LeaseLimitPropertySchema = zod.z.number().int().min(1).max(100).describe("Maximum messages to lease in a single batch (1-100)");
-
-// src/types/errors.ts
-var _a, _b;
-var ZapierError = class extends (_b = Error, _a = CORE_ERROR_SYMBOL, _b) {
-  constructor(message, options = {}) {
-    super(message);
-    this[_a] = true;
-    this.name = "ZapierError";
-    this.code = "ZAPIER_ERROR";
-    if (options.statusCode !== void 0) this.statusCode = options.statusCode;
-    if (options.errors !== void 0) this.errors = options.errors;
-    if (options.cause !== void 0) this.cause = options.cause;
-    if (options.response !== void 0) this.response = options.response;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var ZapierValidationError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierValidationError";
-    this.code = "ZAPIER_VALIDATION_ERROR";
-    this.details = options.details;
+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.`
+      );
+    }
   }
-};
-var ZapierUnknownError = class extends ZapierError {
-  constructor() {
-    super(...arguments);
-    this.name = "ZapierUnknownError";
-    this.code = "ZAPIER_UNKNOWN_ERROR";
+  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
+    });
   }
-};
-var ZapierAuthenticationError = class extends ZapierError {
-  constructor() {
-    super(...arguments);
-    this.name = "ZapierAuthenticationError";
-    this.code = "ZAPIER_AUTHENTICATION_ERROR";
+}
+function buildSurface(context, ...maps) {
+  const sdk = {};
+  for (const map of maps) {
+    Object.defineProperties(sdk, Object.getOwnPropertyDescriptors(map));
   }
-};
-var zapierAdaptError = (options) => {
-  switch (options.code) {
-    case CoreErrorCode.Validation:
-      return new ZapierValidationError(options.message, {
-        cause: options.cause,
-        details: options.details
-      });
-    case CoreErrorCode.Unknown:
-      return new ZapierUnknownError(options.message, {
-        cause: options.cause
-      });
-    default:
-      return new ZapierError(options.message, { cause: options.cause });
+  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]);
   }
-};
-var ZapierApiError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierApiError";
-    this.code = "ZAPIER_API_ERROR";
+  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;
   }
-};
-var ZapierAppNotFoundError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierAppNotFoundError";
-    this.code = "ZAPIER_APP_NOT_FOUND_ERROR";
-    this.appKey = options.appKey;
+  return exports;
+}
+function recordExportSurface(context, exports) {
+  for (const [binding, child] of Object.entries(exports)) {
+    context.surface[binding] = child.id;
   }
-};
-var ZapierNotFoundError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierNotFoundError";
-    this.code = "ZAPIER_NOT_FOUND_ERROR";
+}
+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;
+    }
   }
-};
-var ZapierResourceNotFoundError = class extends ZapierNotFoundError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierResourceNotFoundError";
-    this.code = "ZAPIER_RESOURCE_NOT_FOUND_ERROR";
-    this.resourceType = options.resourceType;
-    this.resourceId = options.resourceId;
+}
+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)
+    };
   }
-};
-var ZapierConfigurationError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierConfigurationError";
-    this.code = "ZAPIER_CONFIGURATION_ERROR";
-    this.configType = options.configType;
+  return out;
+}
+function bindDefinitions(definitions, plugins) {
+  const out = {};
+  for (const [key, def] of Object.entries(definitions)) {
+    out[key] = bindResolver(def, plugins);
   }
-};
-var ZapierBundleError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierBundleError";
-    this.code = "ZAPIER_BUNDLE_ERROR";
-    this.buildErrors = options.buildErrors;
+  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);
+    }
   }
-};
-var ZapierTimeoutError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierTimeoutError";
-    this.code = "ZAPIER_TIMEOUT_ERROR";
-    this.attempts = options.attempts;
-    this.maxAttempts = options.maxAttempts;
+}
+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;
   }
-};
-var ZapierActionError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierActionError";
-    this.code = "ZAPIER_ACTION_ERROR";
-    this.appKey = options.appKey;
-    this.actionKey = options.actionKey;
+}
+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 };
   }
-  // Legacy accessor for backward compatibility
-  get actionErrors() {
-    return this.errors;
+}
+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 });
+    }
   }
-};
-var ZapierConflictError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierConflictError";
-    this.code = "ZAPIER_CONFLICT_ERROR";
-    this.resourceType = options.resourceType;
+}
+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.`
+    );
   }
-};
-var ZapierRateLimitError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierRateLimitError";
-    this.code = "ZAPIER_RATE_LIMIT_ERROR";
-    this.rateLimit = options.rateLimit ?? {};
-    this.retries = options.retries ?? 0;
+  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;
   }
-};
-var ZapierApprovalError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierApprovalError";
-    this.code = "ZAPIER_APPROVAL_ERROR";
-    this.approvalId = options.approvalId;
-    this.approvalStatus = options.status;
-    this.approvalUrl = options.approvalUrl;
-    this.pollUrl = options.pollUrl;
-    this.streamUrl = options.streamUrl;
-    this.reason = options.reason;
+}
+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;
   }
-};
-var ZapierRelayError = class extends ZapierError {
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "ZapierRelayError";
-    this.code = "ZAPIER_RELAY_ERROR";
-  }
-};
-function formatErrorMessage(error) {
-  let message = error.message;
-  if (error.errors && error.errors.length > 0) {
-    const additionalErrors = error.errors.slice(1);
-    if (additionalErrors.length > 0) {
-      const errorDetails = additionalErrors.map((err) => `  \u2022 ${err.detail || err.title || err.code}`).join("\n");
-      message += "\n\nAdditional errors:\n" + errorDetails;
+  addModelPlugin(
+    sdk,
+    plugin,
+    options ?? {}
+  );
+}
+function createCorePlugin(options) {
+  return () => ({
+    context: {
+      core: options
     }
+  });
+}
+function withPositional(schema) {
+  Object.assign(schema._zod.def, {
+    positionalMeta: { positional: true }
+  });
+  return schema;
+}
+function schemaHasPositionalMeta(schema) {
+  return "positionalMeta" in schema._zod.def;
+}
+function isPositional(schema) {
+  if (schemaHasPositionalMeta(schema) && schema._zod.def.positionalMeta?.positional) {
+    return true;
   }
-  if (error instanceof ZapierAppNotFoundError && error.appKey) {
-    message += `
-App key: ${error.appKey}`;
-  }
-  if (error instanceof ZapierActionError && (error.appKey || error.actionKey)) {
-    const context = [];
-    if (error.appKey) context.push(`App: ${error.appKey}`);
-    if (error.actionKey) context.push(`Action: ${error.actionKey}`);
-    message += `
-${context.join(", ")}`;
-  }
-  if (error instanceof ZapierResourceNotFoundError && (error.resourceType || error.resourceId)) {
-    const context = [];
-    if (error.resourceType) context.push(`Type: ${error.resourceType}`);
-    if (error.resourceId) context.push(`ID: ${error.resourceId}`);
-    message += `
-${context.join(", ")}`;
-  }
-  if (error instanceof ZapierConflictError && error.resourceType) {
-    message += `
-Type: ${error.resourceType}`;
-  }
-  if (error instanceof ZapierTimeoutError && (error.attempts || error.maxAttempts)) {
-    const context = [];
-    if (error.attempts) context.push(`Attempts: ${error.attempts}`);
-    if (error.maxAttempts) context.push(`Max attempts: ${error.maxAttempts}`);
-    message += `
-${context.join(", ")}`;
-  }
-  if (error instanceof ZapierBundleError && error.buildErrors && error.buildErrors.length > 0) {
-    message += "\n\nBuild errors:\n" + error.buildErrors.map((err) => `  \u2022 ${err}`).join("\n");
+  if (schema instanceof zod.z.ZodOptional) {
+    return isPositional(schema._zod.def.innerType);
   }
-  if (error instanceof ZapierApprovalError && error.approvalUrl) {
-    message += `
-Approval URL: ${error.approvalUrl}`;
+  if (schema instanceof zod.z.ZodDefault) {
+    return isPositional(schema._zod.def.innerType);
   }
-  if (error instanceof ZapierRateLimitError) {
-    const { limit, remaining, retryAfterMs } = error.rateLimit;
-    const parts = [];
-    if (limit !== void 0) {
-      const used = remaining !== void 0 ? limit - remaining : limit;
-      parts.push(`${used}/${limit} used`);
-    }
-    if (retryAfterMs !== void 0 && retryAfterMs > 0) {
-      parts.push(`retry in ${formatDuration(retryAfterMs)}`);
-    }
-    if (error.retries > 0) {
-      parts.push(
-        `after ${error.retries} retr${error.retries === 1 ? "y" : "ies"}`
-      );
-    }
-    if (parts.length > 0) {
-      message += `
-${parts.join(", ")}`;
-    }
+  return false;
+}
+
+// src/constants.ts
+var ZAPIER_BASE_URL = globalThis.process?.env?.ZAPIER_BASE_URL || "https://zapier.com";
+function getZapierSdkService() {
+  return globalThis.process?.env?.ZAPIER_SDK_SERVICE;
+}
+var MAX_PAGE_LIMIT = 1e4;
+var DEFAULT_PAGE_SIZE = 100;
+var DEFAULT_ACTION_TIMEOUT_MS = 18e4;
+function parseIntEnvVar(name) {
+  const value = globalThis.process?.env?.[name];
+  if (value === void 0) return void 0;
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed)) {
+    console.warn(
+      `[zapier-sdk] Invalid value for ${name}: "${value}" (expected integer)`
+    );
+    return void 0;
   }
-  if (error.statusCode && !message.includes(`${error.statusCode}`)) {
-    message += `
-HTTP Status: ${error.statusCode}`;
+  return parsed;
+}
+var ZAPIER_MAX_NETWORK_RETRIES = parseIntEnvVar("ZAPIER_MAX_NETWORK_RETRIES") ?? 3;
+var ZAPIER_MAX_NETWORK_RETRY_DELAY_MS = parseIntEnvVar("ZAPIER_MAX_NETWORK_RETRY_DELAY_MS") ?? 6e4;
+var MAX_CONCURRENCY_LIMIT = 1e4;
+function parseConcurrencyEnvVar(name) {
+  const value = globalThis.process?.env?.[name];
+  if (!value) return void 0;
+  if (value === "Infinity") return Infinity;
+  if (/^[1-9]\d*$/.test(value)) {
+    const parsed = parseInt(value, 10);
+    if (parsed <= MAX_CONCURRENCY_LIMIT) return parsed;
   }
-  return message;
+  console.warn(
+    `[zapier-sdk] Invalid value for ${name}: "${value}" (expected positive integer 1-${MAX_CONCURRENCY_LIMIT} or "Infinity")`
+  );
+  return void 0;
 }
-function formatDuration(ms) {
-  const seconds = Math.round(ms / 1e3);
-  if (seconds < 60) return `${seconds}s`;
-  const minutes = Math.round(seconds / 60);
-  if (minutes < 60) return `${minutes}m`;
-  const hours = Math.round(minutes / 60);
-  if (hours < 24) return `${hours}h`;
-  const days = Math.round(hours / 24);
-  return `${days}d`;
+var ZAPIER_MAX_CONCURRENT_REQUESTS = parseConcurrencyEnvVar("ZAPIER_MAX_CONCURRENT_REQUESTS") ?? 200;
+function getZapierApprovalMode() {
+  const value = globalThis.process?.env?.ZAPIER_APPROVAL_MODE;
+  if (value === "disabled" || value === "poll" || value === "throw")
+    return value;
+  return void 0;
+}
+function getZapierOpenAutoModeApprovalsInBrowser() {
+  const value = globalThis.process?.env?.ZAPIER_OPEN_AUTO_MODE_APPROVALS_IN_BROWSER;
+  if (value === void 0) return void 0;
+  return value === "true";
 }
+function getZapierDefaultApprovalMode() {
+  const isInteractive = !!globalThis.process?.stdin?.isTTY && !!globalThis.process?.stdout?.isTTY;
+  return isInteractive ? "poll" : "throw";
+}
+var DEFAULT_APPROVAL_TIMEOUT_MS = 10 * 60 * 1e3;
+var DEFAULT_MAX_APPROVAL_RETRIES = 2;
 
-// src/types/signals.ts
-var ZapierSignal = class extends Error {
-  constructor(message) {
+// src/types/properties.ts
+var AppKeyPropertySchema = withPositional(
+  zod.z.string().min(1).describe("App key (e.g., 'SlackCLIAPI' or slug like 'github')")
+);
+var AppPropertySchema = withPositional(
+  zod.z.string().min(1).describe(
+    "App slug (e.g., 'github'), implementation name (e.g., 'SlackCLIAPI'), or versioned ID (e.g., 'github@1.2.3')"
+  )
+);
+var ActionTypePropertySchema = zod.z.enum([
+  "read",
+  "read_bulk",
+  "write",
+  "run",
+  "search",
+  "search_or_write",
+  "search_and_write",
+  "filter"
+]).describe("Action type that matches the action's defined type");
+var ActionKeyPropertySchema = zod.z.string().min(1).describe("Action key to execute");
+var ActionPropertySchema = withPositional(
+  zod.z.string().min(1).describe("Action key (e.g., 'send_message' or 'find_row')")
+);
+var InputFieldPropertySchema = withPositional(
+  zod.z.string().min(1).describe("Input field key to get choices for")
+);
+var ConnectionIdPropertySchema = zod.z.union([zod.z.string(), zod.z.number().int().positive()]).describe("Connection ID to use for this action");
+var AuthenticationIdPropertySchema = ConnectionIdPropertySchema.meta({
+  deprecated: true
+});
+var ConnectionPropertySchema = zod.z.union([zod.z.string(), zod.z.number().int().positive()]).describe(
+  "Connection alias or connection ID (UUID or positive integer). Strings that match a key in the connections map are resolved against it; otherwise the value is used as a connection ID directly."
+);
+var InputsPropertySchema = zod.z.record(zod.z.string(), zod.z.unknown()).describe("Input parameters for the action");
+var LimitPropertySchema = zod.z.number().int().min(1).max(MAX_PAGE_LIMIT).default(50).describe("Maximum number of items to return");
+var OffsetPropertySchema = zod.z.number().int().min(0).default(0).describe("Number of items to skip for pagination");
+var OutputPropertySchema = zod.z.string().describe("Output file path");
+var DebugPropertySchema = zod.z.boolean().default(false).describe("Enable debug logging");
+var ParamsPropertySchema = zod.z.record(zod.z.string(), zod.z.unknown()).describe("Additional parameters");
+var ActionTimeoutMsPropertySchema = zod.z.number().min(1e3).optional().describe(
+  `Maximum time to wait for action completion in milliseconds (default: ${DEFAULT_ACTION_TIMEOUT_MS})`
+);
+var TablePropertySchema = withPositional(
+  zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
+);
+var RecordPropertySchema = withPositional(
+  zod.z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID").describe("The unique identifier of the record")
+);
+var RecordsPropertySchema = zod.z.array(zod.z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID")).min(1).max(100).describe("Record IDs to operate on");
+var FieldsPropertySchema = zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])).describe(
+  'Fields to operate on. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
+);
+var AppsPropertySchema = zod.z.array(zod.z.string()).describe("Filter by app keys (e.g., 'SlackCLIAPI' or slug like 'github')");
+var TablesPropertySchema = zod.z.array(zod.z.string()).describe("Filter by specific table IDs");
+var ConnectionsPropertySchema = zod.z.array(zod.z.string()).describe("List of connection IDs to filter by");
+var TriggerInboxPropertySchema = withPositional(
+  zod.z.string().min(1).describe(
+    "Trigger inbox identifier \u2014 UUID or name. Non-UUID values are resolved by name via the inbox list endpoint."
+  )
+);
+var TriggerInboxNamePropertySchema = zod.z.string().min(1).max(100).describe(
+  "Inbox name; unique per (user, account). Enables get-or-create on createTriggerInbox."
+);
+var LeasePropertySchema = zod.z.string().min(1).describe("Lease ID returned from leaseTriggerInboxMessages");
+var LeaseSecondsPropertySchema = zod.z.number().int().min(1).max(3600).describe(
+  "Seconds until the lease expires; messages return to available if not acked. API default is 300 (5 minutes)."
+);
+var LeaseLimitPropertySchema = zod.z.number().int().min(1).max(100).describe("Maximum messages to lease in a single batch (1-100)");
+
+// src/types/errors.ts
+var _a, _b;
+var ZapierError = class extends (_b = Error, _a = CORE_ERROR_SYMBOL, _b) {
+  constructor(message, options = {}) {
     super(message);
+    this[_a] = true;
+    this.name = "ZapierError";
+    this.code = "ZAPIER_ERROR";
+    if (options.statusCode !== void 0) this.statusCode = options.statusCode;
+    if (options.errors !== void 0) this.errors = options.errors;
+    if (options.cause !== void 0) this.cause = options.cause;
+    if (options.response !== void 0) this.response = options.response;
     Object.setPrototypeOf(this, new.target.prototype);
   }
 };
-var ZapierReleaseTriggerMessageSignal = class extends ZapierSignal {
-  constructor() {
-    super(...arguments);
-    this.name = "ZapierReleaseTriggerMessageSignal";
-    this.code = "ZAPIER_RELEASE_TRIGGER_MESSAGE_SIGNAL";
+var ZapierValidationError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierValidationError";
+    this.code = "ZAPIER_VALIDATION_ERROR";
+    this.details = options.details;
   }
 };
-var ZapierAbortDrainSignal = class extends ZapierSignal {
+var ZapierUnknownError = class extends ZapierError {
   constructor() {
     super(...arguments);
-    this.name = "ZapierAbortDrainSignal";
-    this.code = "ZAPIER_ABORT_DRAIN_SIGNAL";
+    this.name = "ZapierUnknownError";
+    this.code = "ZAPIER_UNKNOWN_ERROR";
+  }
+};
+var ZapierAuthenticationError = class extends ZapierError {
+  constructor() {
+    super(...arguments);
+    this.name = "ZapierAuthenticationError";
+    this.code = "ZAPIER_AUTHENTICATION_ERROR";
+  }
+};
+var zapierAdaptError = (options) => {
+  switch (options.code) {
+    case CoreErrorCode.Validation:
+      return new ZapierValidationError(options.message, {
+        cause: options.cause,
+        details: options.details
+      });
+    case CoreErrorCode.Unknown:
+      return new ZapierUnknownError(options.message, {
+        cause: options.cause
+      });
+    default:
+      return new ZapierError(options.message, { cause: options.cause });
+  }
+};
+var ZapierApiError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierApiError";
+    this.code = "ZAPIER_API_ERROR";
+  }
+};
+var ZapierAppNotFoundError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierAppNotFoundError";
+    this.code = "ZAPIER_APP_NOT_FOUND_ERROR";
+    this.appKey = options.appKey;
+  }
+};
+var ZapierNotFoundError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierNotFoundError";
+    this.code = "ZAPIER_NOT_FOUND_ERROR";
+  }
+};
+var ZapierResourceNotFoundError = class extends ZapierNotFoundError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierResourceNotFoundError";
+    this.code = "ZAPIER_RESOURCE_NOT_FOUND_ERROR";
+    this.resourceType = options.resourceType;
+    this.resourceId = options.resourceId;
+  }
+};
+var ZapierConfigurationError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierConfigurationError";
+    this.code = "ZAPIER_CONFIGURATION_ERROR";
+    this.configType = options.configType;
+  }
+};
+var ZapierBundleError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierBundleError";
+    this.code = "ZAPIER_BUNDLE_ERROR";
+    this.buildErrors = options.buildErrors;
+  }
+};
+var ZapierTimeoutError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierTimeoutError";
+    this.code = "ZAPIER_TIMEOUT_ERROR";
+    this.attempts = options.attempts;
+    this.maxAttempts = options.maxAttempts;
+  }
+};
+var ZapierActionError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierActionError";
+    this.code = "ZAPIER_ACTION_ERROR";
+    this.appKey = options.appKey;
+    this.actionKey = options.actionKey;
+  }
+  // Legacy accessor for backward compatibility
+  get actionErrors() {
+    return this.errors;
+  }
+};
+var ZapierConflictError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierConflictError";
+    this.code = "ZAPIER_CONFLICT_ERROR";
+    this.resourceType = options.resourceType;
+  }
+};
+var ZapierRateLimitError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierRateLimitError";
+    this.code = "ZAPIER_RATE_LIMIT_ERROR";
+    this.rateLimit = options.rateLimit ?? {};
+    this.retries = options.retries ?? 0;
+  }
+};
+var ZapierApprovalError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierApprovalError";
+    this.code = "ZAPIER_APPROVAL_ERROR";
+    this.approvalId = options.approvalId;
+    this.approvalStatus = options.status;
+    this.approvalUrl = options.approvalUrl;
+    this.pollUrl = options.pollUrl;
+    this.streamUrl = options.streamUrl;
+    this.reason = options.reason;
+  }
+};
+var ZapierRelayError = class extends ZapierError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "ZapierRelayError";
+    this.code = "ZAPIER_RELAY_ERROR";
+  }
+};
+function formatErrorMessage(error) {
+  let message = error.message;
+  if (error.errors && error.errors.length > 0) {
+    const additionalErrors = error.errors.slice(1);
+    if (additionalErrors.length > 0) {
+      const errorDetails = additionalErrors.map((err) => `  \u2022 ${err.detail || err.title || err.code}`).join("\n");
+      message += "\n\nAdditional errors:\n" + errorDetails;
+    }
+  }
+  if (error instanceof ZapierAppNotFoundError && error.appKey) {
+    message += `
+App key: ${error.appKey}`;
+  }
+  if (error instanceof ZapierActionError && (error.appKey || error.actionKey)) {
+    const context = [];
+    if (error.appKey) context.push(`App: ${error.appKey}`);
+    if (error.actionKey) context.push(`Action: ${error.actionKey}`);
+    message += `
+${context.join(", ")}`;
+  }
+  if (error instanceof ZapierResourceNotFoundError && (error.resourceType || error.resourceId)) {
+    const context = [];
+    if (error.resourceType) context.push(`Type: ${error.resourceType}`);
+    if (error.resourceId) context.push(`ID: ${error.resourceId}`);
+    message += `
+${context.join(", ")}`;
+  }
+  if (error instanceof ZapierConflictError && error.resourceType) {
+    message += `
+Type: ${error.resourceType}`;
+  }
+  if (error instanceof ZapierTimeoutError && (error.attempts || error.maxAttempts)) {
+    const context = [];
+    if (error.attempts) context.push(`Attempts: ${error.attempts}`);
+    if (error.maxAttempts) context.push(`Max attempts: ${error.maxAttempts}`);
+    message += `
+${context.join(", ")}`;
+  }
+  if (error instanceof ZapierBundleError && error.buildErrors && error.buildErrors.length > 0) {
+    message += "\n\nBuild errors:\n" + error.buildErrors.map((err) => `  \u2022 ${err}`).join("\n");
+  }
+  if (error instanceof ZapierApprovalError && error.approvalUrl) {
+    message += `
+Approval URL: ${error.approvalUrl}`;
+  }
+  if (error instanceof ZapierRateLimitError) {
+    const { limit, remaining, retryAfterMs } = error.rateLimit;
+    const parts = [];
+    if (limit !== void 0) {
+      const used = remaining !== void 0 ? limit - remaining : limit;
+      parts.push(`${used}/${limit} used`);
+    }
+    if (retryAfterMs !== void 0 && retryAfterMs > 0) {
+      parts.push(`retry in ${formatDuration(retryAfterMs)}`);
+    }
+    if (error.retries > 0) {
+      parts.push(
+        `after ${error.retries} retr${error.retries === 1 ? "y" : "ies"}`
+      );
+    }
+    if (parts.length > 0) {
+      message += `
+${parts.join(", ")}`;
+    }
+  }
+  if (error.statusCode && !message.includes(`${error.statusCode}`)) {
+    message += `
+HTTP Status: ${error.statusCode}`;
+  }
+  return message;
+}
+function formatDuration(ms) {
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) return `${hours}h`;
+  const days = Math.round(hours / 24);
+  return `${days}d`;
+}
+
+// src/types/signals.ts
+var ZapierSignal = class extends Error {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ZapierReleaseTriggerMessageSignal = class extends ZapierSignal {
+  constructor() {
+    super(...arguments);
+    this.name = "ZapierReleaseTriggerMessageSignal";
+    this.code = "ZAPIER_RELEASE_TRIGGER_MESSAGE_SIGNAL";
+  }
+};
+var ZapierAbortDrainSignal = class extends ZapierSignal {
+  constructor() {
+    super(...arguments);
+    this.name = "ZapierAbortDrainSignal";
+    this.code = "ZAPIER_ABORT_DRAIN_SIGNAL";
   }
 };
 var TriggerInboxCommandBaseSchema = zod.z.object({
@@ -4898,7 +5756,7 @@ var actionResultItemFormatter = {
       id: getStringProperty(obj, "id"),
       key: getStringProperty(obj, "key"),
       description: getStringProperty(obj, "description"),
-      data: item,
+      raw: item,
       details: []
     };
   }
@@ -5647,8 +6505,10 @@ var UserProfileItemSchema = zod.z.object({
 });
 
 // src/formatters/userProfile.ts
-var userProfileItemFormatter = {
-  format: (item) => {
+var userProfileItemFormatter = defineFormatter({
+  format: ({
+    item
+  }) => {
     const details = [];
     if (item.email) {
       details.push({ text: item.email, style: "dim" });
@@ -5661,41 +6521,38 @@ var userProfileItemFormatter = {
     }
     return {
       title: item.full_name,
-      id: item.id,
+      hint: 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
-        }
-      };
-    }
-  })
-);
+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/api/auth.ts
 function isJwt(token) {
@@ -6997,7 +7854,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:";
@@ -8242,182 +9099,401 @@ var apiPlugin = definePlugin(
   }
 );
 
-// src/utils/batch-utils.ts
-var DEFAULT_CONCURRENCY = 10;
-var BATCH_START_DELAY_MS = 25;
-var DEFAULT_BATCH_TIMEOUT_MS = 18e4;
-async function batch(tasks, options = {}) {
-  const {
-    concurrency = DEFAULT_CONCURRENCY,
-    retry = true,
-    batchDelay = BATCH_START_DELAY_MS,
-    timeoutMs = DEFAULT_BATCH_TIMEOUT_MS,
-    taskTimeoutMs
-  } = options;
-  if (concurrency <= 0) {
-    throw new Error("Concurrency must be greater than 0");
-  }
-  if (timeoutMs <= 0) {
-    throw new Error("Timeout must be greater than 0");
-  }
-  if (taskTimeoutMs !== void 0 && taskTimeoutMs <= 0) {
-    throw new Error("Task timeout must be greater than 0");
-  }
-  if (tasks.length === 0) {
-    return [];
-  }
-  const startTime = Date.now();
-  const results = new Array(tasks.length);
-  const taskQueue = tasks.map((task, index) => ({
-    index,
-    task,
-    errorCount: 0
-  }));
-  async function executeTask(taskState) {
-    const { index, task, errorCount } = taskState;
-    try {
-      let result;
-      if (taskTimeoutMs !== void 0) {
-        const timeoutPromise = sleep(taskTimeoutMs).then(() => {
+// src/core-stack.ts
+var zapierCorePlugin = createCorePlugin({
+  adaptError: zapierAdaptError
+});
+function createZapierCoreStack() {
+  return createPluginStack().use(zapierCorePlugin);
+}
+var GetConnectionStartUrlSchema = zod.z.object({
+  app: AppPropertySchema
+}).describe(
+  "Mint a short-lived URL that begins an SDK-initiated connection flow. The URL is signed by zapier.com and bound to the current user/account \u2014 opening it in a different browser session will fail the binding check. Returns the URL as data so the caller decides what to do with it.\n\nUse this directly (rather than the higher-level `create-connection`) when you want either of: (a) hand off the URL and *not* block waiting for completion \u2014 call this alone, skip `wait-for-new-connection` entirely, or (b) do something custom between minting the URL and waiting for the connection \u2014 call this, then email or DM the URL, render it as a QR code for mobile sign-in, etc., then call `wait-for-new-connection`. For the common case where you'd just print and poll back-to-back, `create-connection` is one call.\n\nPair with `wait-for-new-connection` to detect completion: pass the `startedAt` returned here straight through (it's the server's mint time, so polling isn't affected by client clock skew). Example (JS):\n\n```ts\nconst { data: { url, app, startedAt } } = await zapier.getConnectionStartUrl({ app: 'slack' });\n// hand `url` off \u2014 print it, DM it, email it, render a button, whatever\nconst { data: conn } = await zapier.waitForNewConnection({ app, startedAt });\n```"
+);
+var GetConnectionStartUrlItemSchema = zod.z.object({
+  url: zod.z.string().describe(
+    "URL the user should open in their browser to complete the auth flow. Single-use, time-limited."
+  ),
+  expiresAt: zod.z.number().describe(
+    "Unix timestamp (seconds) after which the URL's signature is rejected by zapier.com."
+  ),
+  startedAt: zod.z.number().describe(
+    "Unix timestamp (seconds) when the server minted the URL. Use it as the `startedAt` for `wait-for-new-connection` so polling is anchored to server time rather than a possibly-skewed client clock."
+  ),
+  app: zod.z.string().describe(
+    "Versionless app key the URL was minted for (e.g., 'SlackCLIAPI'). Useful for downstream filtering."
+  )
+}).describe(
+  "The signed start-URL plus metadata needed to poll for completion."
+);
+
+// src/plugins/getConnectionStartUrl/index.ts
+var START_PATH = "/zapier/api/authentications/v1/sdk/connections/start";
+var getConnectionStartUrlPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    name: "getConnectionStartUrl",
+    categories: ["connection"],
+    type: "create",
+    itemType: "ConnectionStartUrl",
+    inputSchema: GetConnectionStartUrlSchema,
+    outputSchema: GetConnectionStartUrlItemSchema,
+    resolvers: { app: appKeyResolver },
+    handler: async ({
+      sdk: inner,
+      options
+    }) => {
+      const versionedKey = await inner.context.getVersionedImplementationId(
+        options.app
+      );
+      const selectedApi = versionedKey ? versionedKey.split("@")[0] : options.app;
+      setMethodMetadata({ selectedApi });
+      const response = await inner.context.api.post(
+        START_PATH,
+        { selected_api: selectedApi },
+        { authRequired: true }
+      );
+      return {
+        data: GetConnectionStartUrlItemSchema.parse({
+          url: response.url,
+          expiresAt: response.expires_at,
+          startedAt: response.started_at,
+          app: selectedApi
+        })
+      };
+    }
+  })
+);
+var WaitForNewConnectionSchema = zod.z.object({
+  app: AppPropertySchema,
+  startedAt: zod.z.number().int().nonnegative().describe(
+    "Unix timestamp (seconds). Only connections whose `date` is at or after this value count as 'new'. Prefer the `startedAt` returned by `get-connection-start-url` \u2014 it's server-stamped, so the comparison isn't thrown off by client clock skew. If you mint the timestamp yourself, capture it *before* showing the start URL so a fast OAuth completion isn't missed."
+  ),
+  timeoutMs: zod.z.number().int().positive().optional().describe(
+    "How long to wait before giving up. Default 5 minutes (300_000)."
+  ),
+  pollIntervalMs: zod.z.number().int().positive().optional().describe(
+    "Delay before the first poll request, in ms. Default 3 seconds (3_000). Subsequent polling cadence is managed by the SDK's polling primitive (backoff with sane defaults)."
+  )
+}).describe(
+  "Wait for a new connection to appear for the given app. Polls `/api/v0/connections` with server-side `ordering=-date` until the most recent matching row's `date` is at or after the started-at timestamp, then returns it. Pair with `get-connection-start-url` \u2014 that mints the URL the user opens, this waits for the resulting connection to land. Errors with a timeout after the configured timeout (default 5 min). Example (JS):\n\n```ts\nconst { data: { url, app, startedAt } } = await zapier.getConnectionStartUrl({ app: 'slack' });\n// show `url` to the user via the channel they're reading from\nconst { data: conn } = await zapier.waitForNewConnection({ app, startedAt });\n```"
+);
+var WaitForNewConnectionItemSchema = zod.z.object({
+  id: zod.z.string().describe(
+    "The new connection's ID. Public UUID when available, falling back to the numeric ID."
+  ),
+  app: zod.z.string().describe(
+    "Versionless app key the connection was created for (e.g., 'SlackCLIAPI')."
+  ),
+  title: zod.z.string().nullable().optional().describe(
+    "Human-readable connection title set by the auth flow, when available."
+  )
+}).describe("The new connection that was detected.");
+
+// src/plugins/waitForNewConnection/index.ts
+var CONNECTIONS_PATH = "/api/v0/connections";
+var waitForNewConnectionPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    name: "waitForNewConnection",
+    categories: ["connection"],
+    type: "item",
+    itemType: "Connection",
+    inputSchema: WaitForNewConnectionSchema,
+    outputSchema: WaitForNewConnectionItemSchema,
+    resolvers: { app: appKeyResolver },
+    handler: async ({
+      sdk: inner,
+      options
+    }) => {
+      const versionedKey = await inner.context.getVersionedImplementationId(
+        options.app
+      );
+      const appKey = versionedKey ? versionedKey.split("@")[0] : options.app;
+      setMethodMetadata({ selectedApi: appKey });
+      try {
+        const top = await inner.context.api.poll(
+          CONNECTIONS_PATH,
+          {
+            searchParams: {
+              app_key: appKey,
+              // Scope to the current user's own connections. The connection
+              // we're waiting on is by definition owned by the caller; without
+              // this the one-row head-check could match a teammate's freshly
+              // created connection for the same app.
+              owner: "me",
+              is_expired: "false",
+              ordering: "-date",
+              page_size: "1"
+            },
+            authRequired: true,
+            timeoutMs: options.timeoutMs ?? 3e5,
+            initialDelay: options.pollIntervalMs ?? 3e3,
+            isPending: (body) => {
+              const rows = body.data ?? [];
+              const head = rows[0];
+              if (!head?.date) return true;
+              const created = Math.floor(new Date(head.date).getTime() / 1e3);
+              return !Number.isFinite(created) || created < options.startedAt;
+            },
+            resultExtractor: (body) => (
+              // `isPending` guaranteed a fresh row at index 0 before this fires.
+              body.data[0]
+            )
+          }
+        );
+        return {
+          data: WaitForNewConnectionItemSchema.parse({
+            id: String(top.public_id ?? top.id),
+            app: appKey,
+            title: top.title ?? null
+          })
+        };
+      } catch (err) {
+        if (err instanceof ZapierTimeoutError) {
           throw new ZapierTimeoutError(
-            `Task timed out after ${taskTimeoutMs}ms`
+            `Timed out waiting for a new "${appKey}" connection. If the user completed the auth flow, retrieve the connection via sdk.getConnection({ id }) with the ID shown on the completion page.`
           );
-        });
-        result = await Promise.race([task(), timeoutPromise]);
-      } else {
-        result = await task();
-      }
-      results[index] = { status: "fulfilled", value: result };
-    } catch (error) {
-      const newErrorCount = errorCount + 1;
-      const isTimeout = error instanceof ZapierTimeoutError;
-      if (retry && !isTimeout && newErrorCount < MAX_CONSECUTIVE_ERRORS) {
-        const waitTime = calculateErrorBackoffMs(1e3, newErrorCount);
-        await sleep(waitTime);
-        taskQueue.push({
-          index,
-          task,
-          errorCount: newErrorCount
-        });
-      } else {
-        results[index] = { status: "rejected", reason: error };
+        }
+        throw err;
       }
     }
+  })
+);
+
+// src/utils/should-open-browser.ts
+function shouldOpenBrowser() {
+  if (isCiEnv()) return false;
+  const env = globalThis.process?.env;
+  if (env?.SSH_TTY || env?.SSH_CONNECTION) return false;
+  if (globalThis.process?.platform === "linux" && !env?.DISPLAY && !env?.WAYLAND_DISPLAY) {
+    return false;
   }
-  async function worker() {
-    while (taskQueue.length > 0) {
-      const elapsedTime = Date.now() - startTime;
-      if (elapsedTime >= timeoutMs) {
-        throw new ZapierTimeoutError(
-          `Batch operation timed out after ${Math.floor(elapsedTime / 1e3)}s. ${taskQueue.length} task(s) not completed.`
-        );
+  return true;
+}
+function isCiEnv() {
+  const env = globalThis.process?.env;
+  return !!(env?.CI || env?.CONTINUOUS_INTEGRATION || env?.GITHUB_ACTIONS || env?.JENKINS_URL || env?.GITLAB_CI || env?.CIRCLECI || env?.TRAVIS || env?.BUILDKITE || env?.DRONE || env?.BITBUCKET_PIPELINES_UUID);
+}
+var CreateConnectionSchema = zod.z.object({
+  app: AppPropertySchema,
+  browser: zod.z.enum(["auto", "always", "never"]).default("auto").describe(
+    "When to auto-open the URL in a browser. `auto` (default) opens in local sessions and skips opening in CI / SSH / headless-Linux. `always` forces the open attempt. `never` skips it. The URL is always printed to stderr regardless \u2014 a failed or skipped open degrades gracefully to copy-paste."
+  ),
+  timeoutMs: zod.z.number().int().positive().optional().describe(
+    "How long to wait for the user to complete the connection flow before giving up. Default 5 minutes (300_000)."
+  ),
+  pollIntervalMs: zod.z.number().int().positive().optional().describe(
+    "Delay before the first poll request, in ms. Default 3 seconds (3_000). Subsequent polling cadence is managed by the SDK's polling primitive (backoff with sane defaults)."
+  )
+}).describe(
+  "Create a new app connection, end-to-end. Mints the start URL via `get-connection-start-url`, prints it to stderr, opportunistically opens it in a browser when it looks safe to do so (skipping CI / SSH / headless-Linux by default \u2014 pass `--browser always` to force, `--browser never` to suppress), then polls via `wait-for-new-connection` until the user completes OAuth and the new connection appears. Returns the connection.\n\nThis is the right command for most callers. Reach for the lower-level building blocks when you want either of: (a) hand off the URL and *not* block on completion \u2014 call `get-connection-start-url` alone, no `wait-for-new-connection` needed, or (b) do something custom between minting the URL and waiting \u2014 call `get-connection-start-url`, do your work (email or DM the URL, render a QR code, etc.), then `wait-for-new-connection`."
+);
+var CreateConnectionItemSchema = zod.z.object({
+  id: zod.z.string().describe(
+    "The new connection's ID. Public UUID when available, falling back to the numeric ID."
+  ),
+  app: zod.z.string().describe(
+    "Versionless app key the connection was created for (e.g., 'SlackCLIAPI')."
+  ),
+  title: zod.z.string().nullable().optional().describe(
+    "Human-readable connection title set by the auth flow, when available."
+  )
+}).describe("The newly created connection.");
+
+// src/plugins/createConnection/index.ts
+var createConnectionPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    name: "createConnection",
+    categories: ["connection"],
+    type: "create",
+    itemType: "Connection",
+    inputSchema: CreateConnectionSchema,
+    outputSchema: CreateConnectionItemSchema,
+    resolvers: { app: appKeyResolver },
+    formatter: {
+      format: (item) => ({
+        title: `Connection created: ${item.title || item.id}`,
+        id: item.id,
+        details: [
+          { text: `App: ${item.app}`, style: "normal" },
+          { text: `ID:  ${item.id}`, style: "accent" }
+        ]
+      })
+    },
+    handler: async ({
+      sdk: inner,
+      options
+    }) => {
+      const { data: start } = await inner.getConnectionStartUrl({
+        app: options.app
+      });
+      setMethodMetadata({ selectedApi: start.app });
+      console.error(
+        `
+Open this URL to complete the connection:
+  ${start.url}
+`
+      );
+      const shouldOpen = options.browser === "always" || options.browser === "auto" && shouldOpenBrowser();
+      if (shouldOpen) {
+        try {
+          await open_url_default(start.url);
+        } catch {
+        }
       }
-      const taskState = taskQueue.shift();
-      if (!taskState) break;
-      await executeTask(taskState);
-      if (taskQueue.length > 0 && batchDelay > 0) {
-        await sleep(batchDelay);
+      const { data: fresh } = await inner.waitForNewConnection({
+        app: start.app,
+        // Server-stamped mint time: measured on the same clock as a
+        // connection's `date`, so the freshness check is immune to
+        // client/server clock skew.
+        startedAt: start.startedAt,
+        timeoutMs: options.timeoutMs,
+        pollIntervalMs: options.pollIntervalMs
+      });
+      return {
+        data: CreateConnectionItemSchema.parse({
+          id: fresh.id,
+          app: start.app,
+          title: fresh.title ?? null
+        })
+      };
+    }
+  })
+);
+
+// src/plugins/deprecated/authentications.ts
+var listAuthenticationsPlugin = definePlugin(
+  (sdk) => ({
+    listAuthentications: sdk.listConnections,
+    context: {
+      meta: {
+        listAuthentications: {
+          packages: ["cli", "mcp"],
+          categories: ["connection"],
+          deprecation: { message: "Use listConnections instead." },
+          type: "list",
+          itemType: "Connection",
+          inputSchema: ListConnectionsQuerySchema,
+          outputSchema: ConnectionItemSchema,
+          formatter: connectionItemFormatter
+        }
       }
     }
-  }
-  const workerCount = Math.min(concurrency, tasks.length);
-  const workers = [];
-  for (let i = 0; i < workerCount; i++) {
-    workers.push(worker());
-    if (i < workerCount - 1 && batchDelay > 0) {
-      await sleep(batchDelay / 10);
+  })
+);
+var getAuthenticationPlugin = definePlugin(
+  (sdk) => ({
+    getAuthentication: sdk.getConnection,
+    context: {
+      meta: {
+        getAuthentication: {
+          packages: ["cli", "mcp"],
+          categories: ["connection"],
+          deprecation: { message: "Use getConnection instead." },
+          type: "item",
+          itemType: "Connection",
+          inputSchema: GetConnectionParamSchema,
+          outputSchema: ConnectionItemSchema,
+          formatter: connectionItemFormatter
+        }
+      }
     }
-  }
-  await Promise.all(workers);
-  return results;
-}
-
-// src/plugins/connections/index.ts
-var connectionsPlugin = definePlugin(
-  (sdk) => {
-    let cachedMap;
-    async function loadConnectionsMap() {
-      if (cachedMap === void 0) {
-        cachedMap = await sdk.context.getManifestConnections() ?? null;
+  })
+);
+var findFirstAuthenticationPlugin = definePlugin(
+  (sdk) => ({
+    findFirstAuthentication: sdk.findFirstConnection,
+    context: {
+      meta: {
+        findFirstAuthentication: {
+          packages: ["cli", "mcp"],
+          categories: ["connection"],
+          deprecation: { message: "Use findFirstConnection instead." },
+          type: "item",
+          itemType: "Connection",
+          inputSchema: FindFirstConnectionSchema,
+          outputSchema: ConnectionItemSchema,
+          formatter: connectionItemFormatter
+        }
       }
-      return cachedMap;
     }
-    return {
-      context: {
-        resolveConnection: async (name) => {
-          const map = await loadConnectionsMap();
-          return map?.[name];
-        },
-        getConnectionsMap: async () => {
-          return loadConnectionsMap();
+  })
+);
+var findUniqueAuthenticationPlugin = definePlugin(
+  (sdk) => ({
+    findUniqueAuthentication: sdk.findUniqueConnection,
+    context: {
+      meta: {
+        findUniqueAuthentication: {
+          packages: ["cli", "mcp"],
+          categories: ["connection"],
+          deprecation: { message: "Use findUniqueConnection instead." },
+          type: "item",
+          itemType: "Connection",
+          inputSchema: FindUniqueConnectionSchema,
+          outputSchema: ConnectionItemSchema,
+          formatter: connectionItemFormatter
+        }
+      }
+    }
+  })
+);
+
+// src/plugins/deprecated/inputFields.ts
+var listInputFieldsDeprecatedPlugin = definePlugin(
+  (sdk) => ({
+    listInputFields: sdk.listActionInputFields,
+    context: {
+      meta: {
+        listInputFields: {
+          categories: ["action"],
+          deprecation: { message: "Use listActionInputFields instead." },
+          type: "list",
+          itemType: "RootField",
+          inputSchema: ListActionInputFieldsInputSchema,
+          outputSchema: RootFieldItemSchema,
+          formatter: rootFieldItemFormatter,
+          defaultPageSize: DEFAULT_PAGE_SIZE
         }
       }
-    };
-  }
+    }
+  })
 );
-
-// src/plugins/capabilities/index.ts
-function toDescription(key) {
-  const words = key.replace(/^can/, "").replace(/([A-Z])/g, " $1").trim().toLowerCase();
-  return `To ${words}`;
-}
-function toEnvVar(key) {
-  return "ZAPIER_" + key.replace(/([A-Z])/g, "_$1").toUpperCase();
-}
-function toCliFlag(key) {
-  return "--" + key.replace(/([A-Z])/g, "-$1").toLowerCase();
-}
-function buildCapabilityMessage(key) {
-  return [
-    `${toDescription(key)}, use ${toCliFlag(key)} in the CLI,`,
-    `set ${key}: true in SDK options or .zapierrc,`,
-    `or set ${toEnvVar(key)}=true.`
-  ].join(" ");
-}
-var GATED_FLAGS = [
-  "canIncludeSharedConnections",
-  "canIncludeSharedTables",
-  "canDeleteTables"
-];
-function isEnabledByEnv(key) {
-  const value = globalThis.process?.env?.[toEnvVar(key)];
-  if (value === void 0) return void 0;
-  if (value === "true" || value === "1") return true;
-  if (value === "false" || value === "0") return false;
-  return void 0;
-}
-var capabilitiesPlugin = definePlugin(
-  (sdk) => {
-    const options = sdk.context.options ?? {};
-    let cached;
-    async function resolveFlags() {
-      if (cached) return cached;
-      const manifest = await sdk.context.getResolvedManifest();
-      cached = {};
-      for (const flag of GATED_FLAGS) {
-        cached[flag] = Boolean(
-          options[flag] ?? isEnabledByEnv(flag) ?? manifest?.[flag]
-        );
+var listInputFieldChoicesDeprecatedPlugin = definePlugin(
+  (sdk) => ({
+    listInputFieldChoices: sdk.listActionInputFieldChoices,
+    context: {
+      meta: {
+        listInputFieldChoices: {
+          categories: ["action"],
+          deprecation: {
+            message: "Use listActionInputFieldChoices instead."
+          },
+          type: "list",
+          itemType: "InputFieldChoiceItem",
+          inputSchema: ListActionInputFieldChoicesInputSchema,
+          outputSchema: InputFieldChoiceItemSchema,
+          formatter: inputFieldChoiceItemFormatter,
+          defaultPageSize: DEFAULT_PAGE_SIZE
+        }
       }
-      return cached;
     }
-    return {
-      context: {
-        checkCapability: async (key) => {
-          const flags = await resolveFlags();
-          if (flags[key]) return;
-          throw new ZapierConfigurationError(
-            buildCapabilityMessage(key) + " (If you are an AI agent, you MUST NOT retry. Ask the user if they want to enable this.)",
-            { configType: key }
-          );
-        },
-        hasCapability: async (key) => {
-          const flags = await resolveFlags();
-          return flags[key];
+  })
+);
+var getInputFieldsSchemaDeprecatedPlugin = definePlugin(
+  (sdk) => ({
+    getInputFieldsSchema: sdk.getActionInputFieldsSchema,
+    context: {
+      meta: {
+        getInputFieldsSchema: {
+          categories: ["action"],
+          deprecation: { message: "Use getActionInputFieldsSchema instead." },
+          type: "function",
+          inputSchema: GetActionInputFieldsSchemaInputSchema
         }
       }
-    };
-  }
+    }
+  })
 );
 var TableApiItemSchema = zod.z.object({
   id: zod.z.string(),
@@ -8534,256 +9610,67 @@ var listTablesPlugin = definePlugin(
     }
   })
 );
-var GetTableApiResponseSchema = zod.z.object({
-  data: TableApiItemSchema
-});
-var GetTableDescription = "Get detailed information about a specific table";
-var GetTableOptionsSchema = zod.z.object({
-  table: TablePropertySchema
-}).describe(GetTableDescription).meta({ aliases: { tableId: "table" } });
-var GetTableOptionsSchemaDeprecated = zod.z.object({
-  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table to retrieve")
-});
-var GetTableOptionsInputSchema = zod.z.union([GetTableOptionsSchema, GetTableOptionsSchemaDeprecated]).describe(GetTableDescription);
-
-// src/plugins/tables/getTable/index.ts
-var getTablePlugin = definePlugin(
-  (sdk) => createPluginMethod(sdk, {
-    ...tablesDefaults,
-    name: "getTable",
-    type: "item",
-    itemType: "Table",
-    inputSchema: GetTableOptionsInputSchema,
-    outputSchema: TableItemSchema,
-    resolvers: { table: tableIdResolver },
-    handler: async ({ sdk: sdk2, options }) => {
-      const tableId = "table" in options ? options.table : options.tableId;
-      const rawResponse = await sdk2.context.api.get(
-        `/tables/api/v1/tables/${tableId}`,
-        {
-          authRequired: true,
-          resource: { type: "table", id: tableId }
-        }
-      );
-      const response = GetTableApiResponseSchema.parse(rawResponse);
-      return { data: transformTableItem(response.data) };
-    }
-  })
-);
-var CreateTableApiResponseSchema = zod.z.object({
-  data: TableApiItemSchema
-});
-var CreateTableOptionsSchema = zod.z.object({
-  name: zod.z.string().min(1).describe("The name for the new table"),
-  description: zod.z.string().optional().describe("An optional description of the table")
-}).describe("Create a new table");
-
-// src/plugins/tables/createTable/index.ts
-var createTablePlugin = definePlugin(
-  (sdk) => createPluginMethod(sdk, {
-    ...tablesDefaults,
-    name: "createTable",
-    type: "create",
-    itemType: "Table",
-    inputSchema: CreateTableOptionsSchema,
-    outputSchema: TableItemSchema,
-    resolvers: { name: tableNameResolver },
-    handler: async ({ sdk: sdk2, options }) => {
-      const rawResponse = await sdk2.context.api.post(
-        "/tables/api/v1/tables",
-        { name: options.name, description: options.description },
-        { authRequired: true }
-      );
-      const response = CreateTableApiResponseSchema.parse(rawResponse);
-      return { data: transformTableItem(response.data) };
-    }
-  })
-);
-var DeleteTableDescription = "Delete a table by its ID";
-var DeleteTableOptionsSchema = zod.z.object({
-  table: TablePropertySchema
-}).describe(DeleteTableDescription).meta({ aliases: { tableId: "table" } });
-var DeleteTableOptionsSchemaDeprecated = zod.z.object({
-  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table to delete")
-});
-var DeleteTableOptionsInputSchema = zod.z.union([DeleteTableOptionsSchema, DeleteTableOptionsSchemaDeprecated]).describe(DeleteTableDescription);
-
-// src/plugins/tables/deleteTable/index.ts
-var deleteTablePlugin = definePlugin(
-  (sdk) => createPluginMethod(sdk, {
-    ...tablesDefaults,
-    name: "deleteTable",
-    type: "delete",
-    itemType: "Table",
-    inputSchema: DeleteTableOptionsInputSchema,
-    resolvers: { table: tableIdResolver },
-    confirm: "delete",
-    handler: async ({ sdk: sdk2, options }) => {
-      await sdk2.context.checkCapability("canDeleteTables");
-      const tableId = "table" in options ? options.table : options.tableId;
-      await sdk2.context.api.delete(
-        `/tables/api/v1/tables/${tableId}`,
-        void 0,
-        {
-          authRequired: true,
-          resource: { type: "table", id: tableId }
-        }
-      );
-      return { success: true };
-    }
-  })
-);
-
-// src/formatters/tableField.ts
-var tableFieldItemFormatter = {
-  format: (item) => ({
-    title: item.name,
-    id: item.id,
-    details: [{ text: `Type: ${item.type}`, style: "dim" }]
-  })
-};
-
-// src/plugins/tables/listTableFields/index.ts
-var listTableFieldsPlugin = definePlugin(
-  (sdk) => createPluginMethod(sdk, {
-    ...tablesDefaults,
-    name: "listTableFields",
-    type: "list",
-    itemType: "Field",
-    inputSchema: ListTableFieldsOptionsInputSchema,
-    outputSchema: FieldItemSchema,
-    formatter: tableFieldItemFormatter,
-    resolvers: { table: tableIdResolver },
-    handler: async ({ sdk: sdk2, options }) => {
-      const { api } = sdk2.context;
-      const tableId = "table" in options ? options.table : options.tableId;
-      const fieldKeys = "fields" in options ? options.fields : options.fieldKeys;
-      const searchParams = {};
-      if (fieldKeys && fieldKeys.length > 0) {
-        const numericIds = await resolveFieldKeys({
-          api,
-          tableId,
-          fieldKeys
-        });
-        searchParams.field_ids = numericIds.join(",");
-      }
-      if (options.trash) {
-        searchParams.trash = options.trash;
-      }
-      const rawResponse = await api.get(
-        `/tables/api/v1/tables/${tableId}/fields`,
-        {
-          searchParams: Object.keys(searchParams).length > 0 ? searchParams : void 0,
-          authRequired: true,
-          resource: { type: "table", id: tableId }
-        }
-      );
-      const response = ListTableFieldsApiResponseSchema.parse(rawResponse);
-      return { data: response.data.map(transformFieldItem) };
-    }
-  })
-);
-var FieldChangesetItemSchema = zod.z.object({
-  new: FieldApiItemSchema,
-  old: FieldApiItemSchema.nullable(),
-  kind: zod.z.enum(["created", "updated", "deleted"])
-});
-var CreateTableFieldsApiResponseSchema = zod.z.object({
-  data: zod.z.array(FieldChangesetItemSchema),
-  meta: zod.z.object({
-    did_change: zod.z.boolean()
-  }).optional()
-});
-var NewFieldSchema = zod.z.object({
-  type: FieldTypeSchema.describe("The data type of the field"),
-  name: zod.z.string().min(1).describe("The display name of the field"),
-  options: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Data configuration options for the field"),
-  config: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Display configuration for the field")
-});
-var CreateTableFieldsDescription = "Create one or more fields in a table";
-var CreateTableFieldsBase = zod.z.object({
-  fields: zod.z.array(NewFieldSchema).min(1).describe("Array of field definitions to create")
+var GetTableApiResponseSchema = zod.z.object({
+  data: TableApiItemSchema
 });
-var CreateTableFieldsOptionsSchema = zod.z.object({
+var GetTableDescription = "Get detailed information about a specific table";
+var GetTableOptionsSchema = zod.z.object({
   table: TablePropertySchema
-}).merge(CreateTableFieldsBase).describe(CreateTableFieldsDescription).meta({ aliases: { tableId: "table" } });
-var CreateTableFieldsOptionsSchemaDeprecated = zod.z.object({
-  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
-}).merge(CreateTableFieldsBase);
-var CreateTableFieldsOptionsInputSchema = zod.z.union([
-  CreateTableFieldsOptionsSchema,
-  CreateTableFieldsOptionsSchemaDeprecated
-]).describe(CreateTableFieldsDescription);
+}).describe(GetTableDescription).meta({ aliases: { tableId: "table" } });
+var GetTableOptionsSchemaDeprecated = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table to retrieve")
+});
+var GetTableOptionsInputSchema = zod.z.union([GetTableOptionsSchema, GetTableOptionsSchemaDeprecated]).describe(GetTableDescription);
 
-// src/plugins/tables/createTableFields/index.ts
-var createTableFieldsPlugin = definePlugin(
+// src/plugins/tables/getTable/index.ts
+var getTablePlugin = definePlugin(
   (sdk) => createPluginMethod(sdk, {
     ...tablesDefaults,
-    name: "createTableFields",
-    type: "create",
-    itemType: "Field",
-    returnType: "FieldItem[]",
-    inputSchema: CreateTableFieldsOptionsInputSchema,
-    outputSchema: FieldItemSchema,
-    formatter: tableFieldItemFormatter,
-    resolvers: { table: tableIdResolver, fields: tableFieldsResolver },
+    name: "getTable",
+    type: "item",
+    itemType: "Table",
+    inputSchema: GetTableOptionsInputSchema,
+    outputSchema: TableItemSchema,
+    resolvers: { table: tableIdResolver },
     handler: async ({ sdk: sdk2, options }) => {
       const tableId = "table" in options ? options.table : options.tableId;
-      const rawResponse = await sdk2.context.api.post(
-        `/tables/api/v1/tables/${tableId}/fields`,
-        { new_fields: options.fields },
+      const rawResponse = await sdk2.context.api.get(
+        `/tables/api/v1/tables/${tableId}`,
         {
           authRequired: true,
           resource: { type: "table", id: tableId }
         }
       );
-      const response = CreateTableFieldsApiResponseSchema.parse(rawResponse);
-      return {
-        data: response.data.map(
-          (changeset) => transformFieldItem(changeset.new)
-        )
-      };
+      const response = GetTableApiResponseSchema.parse(rawResponse);
+      return { data: transformTableItem(response.data) };
     }
   })
 );
-var DeleteTableFieldsDescription = "Delete one or more fields from a table";
-var DeleteTableFieldsOptionsSchema = zod.z.object({
-  table: TablePropertySchema,
-  fields: FieldsPropertySchema.min(1)
-}).describe(DeleteTableFieldsDescription).meta({ aliases: { tableId: "table", fieldKeys: "fields" } });
-var DeleteTableFieldsOptionsSchemaDeprecated = zod.z.object({
-  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
-  fieldKeys: zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])).min(1).describe(
-    'Fields to delete. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
-  )
+var DeleteTableDescription = "Delete a table by its ID";
+var DeleteTableOptionsSchema = zod.z.object({
+  table: TablePropertySchema
+}).describe(DeleteTableDescription).meta({ aliases: { tableId: "table" } });
+var DeleteTableOptionsSchemaDeprecated = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table to delete")
 });
-var DeleteTableFieldsOptionsInputSchema = zod.z.union([
-  DeleteTableFieldsOptionsSchema,
-  DeleteTableFieldsOptionsSchemaDeprecated
-]).describe(DeleteTableFieldsDescription);
+var DeleteTableOptionsInputSchema = zod.z.union([DeleteTableOptionsSchema, DeleteTableOptionsSchemaDeprecated]).describe(DeleteTableDescription);
 
-// src/plugins/tables/deleteTableFields/index.ts
-var deleteTableFieldsPlugin = definePlugin(
+// src/plugins/tables/deleteTable/index.ts
+var deleteTablePlugin = definePlugin(
   (sdk) => createPluginMethod(sdk, {
     ...tablesDefaults,
-    name: "deleteTableFields",
+    name: "deleteTable",
     type: "delete",
-    itemType: "Field",
-    inputSchema: DeleteTableFieldsOptionsInputSchema,
-    resolvers: { table: tableIdResolver, fields: tableFieldIdsResolver },
+    itemType: "Table",
+    inputSchema: DeleteTableOptionsInputSchema,
+    resolvers: { table: tableIdResolver },
     confirm: "delete",
     handler: async ({ sdk: sdk2, options }) => {
-      const { api } = sdk2.context;
+      await sdk2.context.checkCapability("canDeleteTables");
       const tableId = "table" in options ? options.table : options.tableId;
-      const fieldKeys = "fields" in options ? options.fields : options.fieldKeys;
-      const numericFieldIds = await resolveFieldKeys({
-        api,
-        tableId,
-        fieldKeys
-      });
-      await api.delete(
-        `/tables/api/v1/tables/${tableId}/fields`,
-        { field_ids: numericFieldIds },
+      await sdk2.context.api.delete(
+        `/tables/api/v1/tables/${tableId}`,
+        void 0,
         {
           authRequired: true,
           resource: { type: "table", id: tableId }
@@ -8793,820 +9680,700 @@ var deleteTableFieldsPlugin = definePlugin(
     }
   })
 );
-var RecordApiItemSchema = zod.z.object({
-  id: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID"),
-  data: zod.z.record(zod.z.string(), zod.z.unknown()),
-  created_at: zod.z.string(),
-  edited_at: zod.z.string(),
-  schema_revision_id: zod.z.number(),
-  errors: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
-  orig_data: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
-  is_source_record: zod.z.boolean().nullable().optional(),
-  deleted_at: zod.z.string().nullable().optional()
-});
-var RecordItemSchema = zod.z.object({
-  id: zod.z.string(),
-  data: zod.z.record(zod.z.string(), zod.z.unknown()),
-  created_at: zod.z.string(),
-  edited_at: zod.z.string(),
-  deleted_at: zod.z.string().nullable().optional()
-});
-var GetTableRecordApiResponseSchema = zod.z.object({
-  data: RecordApiItemSchema
-});
-var GetTableRecordDescription = "Get a single record from a table by ID";
-var GetTableRecordOptionsBaseSchema = zod.z.object({
-  keyMode: KeyModeSchema
-});
-var GetTableRecordOptionsSchema = zod.z.object({
-  table: TablePropertySchema,
-  record: RecordPropertySchema
-}).merge(GetTableRecordOptionsBaseSchema).describe(GetTableRecordDescription).meta({ aliases: { tableId: "table", recordId: "record" } });
-var GetTableRecordOptionsSchemaDeprecated = zod.z.object({
-  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
-  recordId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID").describe("The unique identifier of the record")
-}).merge(GetTableRecordOptionsBaseSchema);
-var GetTableRecordOptionsInputSchema = zod.z.union([GetTableRecordOptionsSchema, GetTableRecordOptionsSchemaDeprecated]).describe(GetTableRecordDescription);
-
-// src/formatters/tableRecord.ts
-var tableRecordFormatter = {
-  fetch: async (sdk, params, item, context) => {
-    if (context) return context;
-    const hasFieldIds = Object.keys(item.data).some(isFieldId);
-    if (!hasFieldIds) return {};
-    const table = params.table ?? params.tableId;
-    if (!table) return {};
-    const { data: fields } = await sdk.listTableFields({ table });
-    return Object.fromEntries(fields.map((f) => [f.id, f.name]));
-  },
-  format: (item, fieldLabels) => ({
-    title: `Record ${item.id}`,
-    id: item.id,
-    details: Object.entries(item.data).map(([k, v]) => ({
-      label: fieldLabels?.[k] ?? k,
-      text: formatFieldValue(v),
-      style: "normal"
-    }))
-  })
-};
-
-// src/plugins/tables/getTableRecord/index.ts
-var getTableRecordPlugin = definePlugin(
-  (sdk) => createPluginMethod(sdk, {
-    ...tablesDefaults,
-    name: "getTableRecord",
-    type: "item",
-    itemType: "Record",
-    inputSchema: GetTableRecordOptionsInputSchema,
-    outputSchema: RecordItemSchema,
-    resolvers: { table: tableIdResolver, record: tableRecordIdResolver },
-    formatter: tableRecordFormatter,
-    handler: async ({ sdk: sdk2, options }) => {
-      const { api } = sdk2.context;
-      const tableId = "table" in options ? options.table : options.tableId;
-      const recordId = "record" in options ? options.record : options.recordId;
-      const rawResponse = await api.get(
-        `/tables/api/v1/tables/${tableId}/records/${recordId}`,
-        {
-          authRequired: true,
-          resource: { type: "record", id: recordId }
-        }
-      );
-      const response = GetTableRecordApiResponseSchema.parse(rawResponse);
-      const translator = await createFieldKeyTranslator({
-        api,
-        tableId,
-        keyMode: options.keyMode
-      });
-      return {
-        data: {
-          ...transformRecordItem(response.data),
-          data: translator.translateOutput(response.data.data)
-        }
-      };
-    }
-  })
-);
-var ListTableRecordsApiResponseSchema = zod.z.object({
-  data: zod.z.array(RecordApiItemSchema),
-  meta: zod.z.object({
-    pagination: zod.z.object({
-      start_cursor: zod.z.string().nullable().optional(),
-      end_cursor: zod.z.string().nullable().optional(),
-      has_more: zod.z.boolean().optional(),
-      has_less: zod.z.boolean().optional()
-    }).optional()
-  }).optional()
-});
-var FilterOperatorSchema = zod.z.enum([
-  "exact",
-  "different",
-  "contains",
-  "icontains",
-  "gte",
-  "gt",
-  "lt",
-  "lte",
-  "range",
-  "in",
-  "isnull",
-  "startswith",
-  "search",
-  "is_within"
-]);
-var FilterConditionSchema = zod.z.object({
-  fieldKey: zod.z.string().describe("The field key to filter on (e.g. f1, f2)"),
-  operator: FilterOperatorSchema.describe("The comparison operator"),
-  value: zod.z.unknown().optional().describe("The value to compare against")
-});
-var SortDirectionSchema = zod.z.enum(["asc", "desc"]);
-var SortConditionSchema = zod.z.object({
-  fieldKey: zod.z.string().describe("The field key to sort by"),
-  direction: SortDirectionSchema.optional().default("asc").describe("Sort direction")
-});
-var ListTableRecordsDescription = "List records in a table with optional filtering and sorting";
-var ListTableRecordsBase = zod.z.object({
-  filters: zod.z.array(FilterConditionSchema).optional().describe("Filter conditions for the query"),
-  sort: SortConditionSchema.optional().describe("Sort records by a field"),
-  pageSize: zod.z.number().min(1).max(1e3).optional().describe("Number of records per page (max 1000)"),
-  maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages"),
-  cursor: zod.z.string().optional().describe("Cursor to start from"),
-  keyMode: KeyModeSchema,
-  trash: TrashSchema
+var CreateTableApiResponseSchema = zod.z.object({
+  data: TableApiItemSchema
 });
-var ListTableRecordsOptionsSchema = zod.z.object({
-  table: TablePropertySchema
-}).merge(ListTableRecordsBase).describe(ListTableRecordsDescription).meta({ aliases: { tableId: "table" } });
-var ListTableRecordsOptionsSchemaDeprecated = zod.z.object({
-  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
-}).merge(ListTableRecordsBase);
-var ListTableRecordsOptionsInputSchema = zod.z.union([
-  ListTableRecordsOptionsSchema,
-  ListTableRecordsOptionsSchemaDeprecated
-]).describe(ListTableRecordsDescription);
+var CreateTableOptionsSchema = zod.z.object({
+  name: zod.z.string().min(1).describe("The name for the new table"),
+  description: zod.z.string().optional().describe("An optional description of the table")
+}).describe("Create a new table");
 
-// src/plugins/tables/listTableRecords/index.ts
-var listTableRecordsPlugin = definePlugin(
-  (sdk) => createPaginatedPluginMethod(sdk, {
+// src/plugins/tables/createTable/index.ts
+var createTablePlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
     ...tablesDefaults,
-    name: "listTableRecords",
+    name: "createTable",
+    type: "create",
+    itemType: "Table",
+    inputSchema: CreateTableOptionsSchema,
+    outputSchema: TableItemSchema,
+    resolvers: { name: tableNameResolver },
+    handler: async ({ sdk: sdk2, options }) => {
+      const rawResponse = await sdk2.context.api.post(
+        "/tables/api/v1/tables",
+        { name: options.name, description: options.description },
+        { authRequired: true }
+      );
+      const response = CreateTableApiResponseSchema.parse(rawResponse);
+      return { data: transformTableItem(response.data) };
+    }
+  })
+);
+
+// src/formatters/tableField.ts
+var tableFieldItemFormatter = {
+  format: (item) => ({
+    title: item.name,
+    id: item.id,
+    details: [{ text: `Type: ${item.type}`, style: "dim" }]
+  })
+};
+
+// src/plugins/tables/listTableFields/index.ts
+var listTableFieldsPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...tablesDefaults,
+    name: "listTableFields",
     type: "list",
-    itemType: "Record",
-    inputSchema: ListTableRecordsOptionsInputSchema,
-    outputSchema: RecordItemSchema,
-    defaultPageSize: DEFAULT_PAGE_SIZE,
-    resolvers: {
-      table: tableIdResolver,
-      filters: tableFiltersResolver,
-      sort: tableSortResolver
-    },
-    formatter: tableRecordFormatter,
+    itemType: "Field",
+    inputSchema: ListTableFieldsOptionsInputSchema,
+    outputSchema: FieldItemSchema,
+    formatter: tableFieldItemFormatter,
+    resolvers: { table: tableIdResolver },
     handler: async ({ sdk: sdk2, options }) => {
       const { api } = sdk2.context;
       const tableId = "table" in options ? options.table : options.tableId;
-      const translator = await createFieldKeyTranslator({
-        api,
-        tableId,
-        keyMode: options.keyMode
-      });
-      const body = {};
-      if (options.pageSize !== void 0) {
-        body.limit = options.pageSize;
-      }
-      if (options.filters) {
-        body.filters = options.filters.map((f) => ({
-          key: translator.translateFieldKey(f.fieldKey),
-          operator: f.operator,
-          value: f.value
-        }));
-      }
-      if (options.sort) {
-        body.orders = [
-          {
-            key: translator.translateFieldKey(options.sort.fieldKey),
-            direction: options.sort.direction
-          }
-        ];
-      }
-      if (options.cursor) {
-        body.cursor_query = {
-          query_type: "window",
-          start_cursor: options.cursor
-        };
+      const fieldKeys = "fields" in options ? options.fields : options.fieldKeys;
+      const searchParams = {};
+      if (fieldKeys && fieldKeys.length > 0) {
+        const numericIds = await resolveFieldKeys({
+          api,
+          tableId,
+          fieldKeys
+        });
+        searchParams.field_ids = numericIds.join(",");
       }
-      const searchParams = {
-        allow_nested_queries: "true"
-      };
       if (options.trash) {
         searchParams.trash = options.trash;
       }
-      const rawResponse = await api.post(
-        `/tables/api/v1/tables/${tableId}/records/query`,
-        body,
+      const rawResponse = await api.get(
+        `/tables/api/v1/tables/${tableId}/fields`,
         {
-          searchParams,
+          searchParams: Object.keys(searchParams).length > 0 ? searchParams : void 0,
           authRequired: true,
           resource: { type: "table", id: tableId }
         }
       );
-      throwOnResponseErrors(rawResponse);
-      const response = ListTableRecordsApiResponseSchema.parse(rawResponse);
-      const pagination = response.meta?.pagination;
-      const nextCursor = pagination?.has_more && pagination.end_cursor ? pagination.end_cursor : void 0;
-      return {
-        data: response.data.map((item) => ({
-          ...transformRecordItem(item),
-          data: translator.translateOutput(item.data)
-        })),
-        nextCursor
-      };
+      const response = ListTableFieldsApiResponseSchema.parse(rawResponse);
+      return { data: response.data.map(transformFieldItem) };
     }
   })
 );
-var RecordChangesetSchema = zod.z.object({
-  change_id: zod.z.string(),
-  old: RecordApiItemSchema.nullable(),
-  new: RecordApiItemSchema,
-  changed_field_ids: zod.z.array(zod.z.number()).nullable(),
-  record_id: zod.z.string()
+var FieldChangesetItemSchema = zod.z.object({
+  new: FieldApiItemSchema,
+  old: FieldApiItemSchema.nullable(),
+  kind: zod.z.enum(["created", "updated", "deleted"])
 });
-var CreateTableRecordsApiResponseSchema = zod.z.object({
-  data: zod.z.array(RecordChangesetSchema)
+var CreateTableFieldsApiResponseSchema = zod.z.object({
+  data: zod.z.array(FieldChangesetItemSchema),
+  meta: zod.z.object({
+    did_change: zod.z.boolean()
+  }).optional()
 });
-var NewRecordSchema = zod.z.object({
-  data: zod.z.record(zod.z.string(), zod.z.unknown()).describe("The field values for the record, keyed by field ID")
+var NewFieldSchema = zod.z.object({
+  type: FieldTypeSchema.describe("The data type of the field"),
+  name: zod.z.string().min(1).describe("The display name of the field"),
+  options: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Data configuration options for the field"),
+  config: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Display configuration for the field")
 });
-var CreateTableRecordsDescription = "Create one or more records in a table";
-var CreateTableRecordsBase = zod.z.object({
-  records: zod.z.array(NewRecordSchema).min(1).max(100).describe("Array of records to create (max 100)"),
-  keyMode: KeyModeSchema
+var CreateTableFieldsDescription = "Create one or more fields in a table";
+var CreateTableFieldsBase = zod.z.object({
+  fields: zod.z.array(NewFieldSchema).min(1).describe("Array of field definitions to create")
 });
-var CreateTableRecordsOptionsSchema = zod.z.object({
+var CreateTableFieldsOptionsSchema = zod.z.object({
   table: TablePropertySchema
-}).merge(CreateTableRecordsBase).describe(CreateTableRecordsDescription).meta({ aliases: { tableId: "table" } });
-var CreateTableRecordsOptionsSchemaDeprecated = zod.z.object({
+}).merge(CreateTableFieldsBase).describe(CreateTableFieldsDescription).meta({ aliases: { tableId: "table" } });
+var CreateTableFieldsOptionsSchemaDeprecated = zod.z.object({
   tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
-}).merge(CreateTableRecordsBase);
-var CreateTableRecordsOptionsInputSchema = zod.z.union([
-  CreateTableRecordsOptionsSchema,
-  CreateTableRecordsOptionsSchemaDeprecated
-]).describe(CreateTableRecordsDescription);
+}).merge(CreateTableFieldsBase);
+var CreateTableFieldsOptionsInputSchema = zod.z.union([
+  CreateTableFieldsOptionsSchema,
+  CreateTableFieldsOptionsSchemaDeprecated
+]).describe(CreateTableFieldsDescription);
 
-// src/plugins/tables/createTableRecords/index.ts
-var createTableRecordsPlugin = definePlugin(
+// src/plugins/tables/createTableFields/index.ts
+var createTableFieldsPlugin = definePlugin(
   (sdk) => createPluginMethod(sdk, {
     ...tablesDefaults,
-    name: "createTableRecords",
+    name: "createTableFields",
     type: "create",
-    itemType: "Record",
-    returnType: "RecordItem[]",
-    inputSchema: CreateTableRecordsOptionsInputSchema,
-    outputSchema: RecordItemSchema,
-    resolvers: { table: tableIdResolver, records: tableRecordsResolver },
-    formatter: tableRecordFormatter,
-    handler: async ({ sdk: sdk2, options }) => {
-      const { api } = sdk2.context;
-      const tableId = "table" in options ? options.table : options.tableId;
-      const translator = await createFieldKeyTranslator({
-        api,
-        tableId,
-        keyMode: options.keyMode
-      });
-      const rawResponse = await api.post(
-        `/tables/api/v1/tables/${tableId}/records`,
-        {
-          new_records: options.records.map((record) => ({
-            data: translator.translateInput(record.data)
-          }))
-        },
-        { authRequired: true, resource: { type: "table", id: tableId } }
-      );
-      throwOnResponseErrors(rawResponse);
-      const response = CreateTableRecordsApiResponseSchema.parse(rawResponse);
-      for (const changeset of response.data) {
-        throwOnRecordErrors(changeset.new);
-      }
-      return {
-        data: response.data.map((changeset) => ({
-          ...transformRecordItem(changeset.new),
-          data: translator.translateOutput(changeset.new.data)
-        }))
-      };
-    }
-  })
-);
-var DeleteTableRecordsDescription = "Delete one or more records from a table";
-var DeleteTableRecordsOptionsSchema = zod.z.object({
-  table: TablePropertySchema,
-  records: RecordsPropertySchema
-}).describe(DeleteTableRecordsDescription).meta({ aliases: { tableId: "table", recordIds: "records" } });
-var DeleteTableRecordsOptionsSchemaDeprecated = zod.z.object({
-  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
-  recordIds: zod.z.array(zod.z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID")).min(1).max(100).describe("Array of record IDs to delete (max 100)")
-});
-var DeleteTableRecordsOptionsInputSchema = zod.z.union([
-  DeleteTableRecordsOptionsSchema,
-  DeleteTableRecordsOptionsSchemaDeprecated
-]).describe(DeleteTableRecordsDescription);
-
-// src/plugins/tables/deleteTableRecords/index.ts
-var deleteTableRecordsPlugin = definePlugin(
-  (sdk) => createPluginMethod(sdk, {
-    ...tablesDefaults,
-    name: "deleteTableRecords",
-    type: "delete",
-    itemType: "Record",
-    inputSchema: DeleteTableRecordsOptionsInputSchema,
-    resolvers: { table: tableIdResolver, records: tableRecordIdsResolver },
-    confirm: "delete",
-    handler: async ({ sdk: sdk2, options }) => {
-      const tableId = "table" in options ? options.table : options.tableId;
-      const recordIds = "records" in options ? options.records : options.recordIds;
-      await sdk2.context.api.delete(
-        `/tables/api/v1/tables/${tableId}/records`,
-        { record_ids: recordIds },
+    itemType: "Field",
+    returnType: "FieldItem[]",
+    inputSchema: CreateTableFieldsOptionsInputSchema,
+    outputSchema: FieldItemSchema,
+    formatter: tableFieldItemFormatter,
+    resolvers: { table: tableIdResolver, fields: tableFieldsResolver },
+    handler: async ({ sdk: sdk2, options }) => {
+      const tableId = "table" in options ? options.table : options.tableId;
+      const rawResponse = await sdk2.context.api.post(
+        `/tables/api/v1/tables/${tableId}/fields`,
+        { new_fields: options.fields },
         {
           authRequired: true,
           resource: { type: "table", id: tableId }
         }
       );
-      return { success: true };
+      const response = CreateTableFieldsApiResponseSchema.parse(rawResponse);
+      return {
+        data: response.data.map(
+          (changeset) => transformFieldItem(changeset.new)
+        )
+      };
     }
   })
 );
-var RecordChangesetSchema2 = zod.z.object({
-  change_id: zod.z.string(),
-  old: RecordApiItemSchema.nullable(),
-  new: RecordApiItemSchema,
-  changed_field_ids: zod.z.array(zod.z.number()).nullable(),
-  record_id: zod.z.string()
-});
-var UpdateTableRecordsApiResponseSchema = zod.z.object({
-  data: zod.z.array(RecordChangesetSchema2)
-});
-var UpdateRecordSchema = zod.z.object({
-  id: zod.z.string().describe("The record ID to update"),
-  data: zod.z.record(zod.z.string(), zod.z.unknown()).describe("The field values to update, keyed by field key")
-});
-var UpdateTableRecordsDescription = "Update one or more records in a table";
-var UpdateTableRecordsBase = zod.z.object({
-  records: zod.z.array(UpdateRecordSchema).min(1).max(100).describe("Array of records to update (max 100)"),
-  keyMode: KeyModeSchema
+var DeleteTableFieldsDescription = "Delete one or more fields from a table";
+var DeleteTableFieldsOptionsSchema = zod.z.object({
+  table: TablePropertySchema,
+  fields: FieldsPropertySchema.min(1)
+}).describe(DeleteTableFieldsDescription).meta({ aliases: { tableId: "table", fieldKeys: "fields" } });
+var DeleteTableFieldsOptionsSchemaDeprecated = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  fieldKeys: zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])).min(1).describe(
+    'Fields to delete. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
+  )
 });
-var UpdateTableRecordsOptionsSchema = zod.z.object({
-  table: TablePropertySchema
-}).merge(UpdateTableRecordsBase).describe(UpdateTableRecordsDescription).meta({ aliases: { tableId: "table" } });
-var UpdateTableRecordsOptionsSchemaDeprecated = zod.z.object({
-  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
-}).merge(UpdateTableRecordsBase);
-var UpdateTableRecordsOptionsInputSchema = zod.z.union([
-  UpdateTableRecordsOptionsSchema,
-  UpdateTableRecordsOptionsSchemaDeprecated
-]).describe(UpdateTableRecordsDescription);
+var DeleteTableFieldsOptionsInputSchema = zod.z.union([
+  DeleteTableFieldsOptionsSchema,
+  DeleteTableFieldsOptionsSchemaDeprecated
+]).describe(DeleteTableFieldsDescription);
 
-// src/plugins/tables/updateTableRecords/index.ts
-var updateTableRecordsPlugin = definePlugin(
+// src/plugins/tables/deleteTableFields/index.ts
+var deleteTableFieldsPlugin = definePlugin(
   (sdk) => createPluginMethod(sdk, {
     ...tablesDefaults,
-    name: "updateTableRecords",
-    type: "update",
-    itemType: "Record",
-    returnType: "RecordItem[]",
-    inputSchema: UpdateTableRecordsOptionsInputSchema,
-    outputSchema: RecordItemSchema,
-    resolvers: {
-      table: tableIdResolver,
-      records: tableUpdateRecordsResolver
-    },
-    formatter: tableRecordFormatter,
+    name: "deleteTableFields",
+    type: "delete",
+    itemType: "Field",
+    inputSchema: DeleteTableFieldsOptionsInputSchema,
+    resolvers: { table: tableIdResolver, fields: tableFieldIdsResolver },
+    confirm: "delete",
     handler: async ({ sdk: sdk2, options }) => {
       const { api } = sdk2.context;
       const tableId = "table" in options ? options.table : options.tableId;
-      const translator = await createFieldKeyTranslator({
+      const fieldKeys = "fields" in options ? options.fields : options.fieldKeys;
+      const numericFieldIds = await resolveFieldKeys({
         api,
         tableId,
-        keyMode: options.keyMode
+        fieldKeys
       });
-      const rawResponse = await api.patch(
-        `/tables/api/v1/tables/${tableId}/records`,
+      await api.delete(
+        `/tables/api/v1/tables/${tableId}/fields`,
+        { field_ids: numericFieldIds },
         {
-          updated_records: options.records.map((record) => ({
-            id: record.id,
-            data: translator.translateInput(record.data)
-          }))
-        },
-        { authRequired: true, resource: { type: "table", id: tableId } }
+          authRequired: true,
+          resource: { type: "table", id: tableId }
+        }
       );
-      throwOnResponseErrors(rawResponse);
-      const response = UpdateTableRecordsApiResponseSchema.parse(rawResponse);
-      for (const changeset of response.data) {
-        throwOnRecordErrors(changeset.new);
-      }
-      return {
-        data: response.data.map((changeset) => ({
-          ...transformRecordItem(changeset.new),
-          data: translator.translateOutput(changeset.new.data)
-        }))
-      };
+      return { success: true };
     }
   })
 );
-
-// src/core-stack.ts
-var zapierCorePlugin = createCorePlugin({
-  adaptError: zapierAdaptError
+var RecordApiItemSchema = zod.z.object({
+  id: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID"),
+  data: zod.z.record(zod.z.string(), zod.z.unknown()),
+  created_at: zod.z.string(),
+  edited_at: zod.z.string(),
+  schema_revision_id: zod.z.number(),
+  errors: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
+  orig_data: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
+  is_source_record: zod.z.boolean().nullable().optional(),
+  deleted_at: zod.z.string().nullable().optional()
 });
-function createZapierCoreStack() {
-  return createPluginStack().use(zapierCorePlugin);
-}
-var GetConnectionStartUrlSchema = zod.z.object({
-  app: AppPropertySchema
-}).describe(
-  "Mint a short-lived URL that begins an SDK-initiated connection flow. The URL is signed by zapier.com and bound to the current user/account \u2014 opening it in a different browser session will fail the binding check. Returns the URL as data so the caller decides what to do with it.\n\nUse this directly (rather than the higher-level `create-connection`) when you want either of: (a) hand off the URL and *not* block waiting for completion \u2014 call this alone, skip `wait-for-new-connection` entirely, or (b) do something custom between minting the URL and waiting for the connection \u2014 call this, then email or DM the URL, render it as a QR code for mobile sign-in, etc., then call `wait-for-new-connection`. For the common case where you'd just print and poll back-to-back, `create-connection` is one call.\n\nPair with `wait-for-new-connection` to detect completion: pass the `startedAt` returned here straight through (it's the server's mint time, so polling isn't affected by client clock skew). Example (JS):\n\n```ts\nconst { data: { url, app, startedAt } } = await zapier.getConnectionStartUrl({ app: 'slack' });\n// hand `url` off \u2014 print it, DM it, email it, render a button, whatever\nconst { data: conn } = await zapier.waitForNewConnection({ app, startedAt });\n```"
-);
-var GetConnectionStartUrlItemSchema = zod.z.object({
-  url: zod.z.string().describe(
-    "URL the user should open in their browser to complete the auth flow. Single-use, time-limited."
-  ),
-  expiresAt: zod.z.number().describe(
-    "Unix timestamp (seconds) after which the URL's signature is rejected by zapier.com."
-  ),
-  startedAt: zod.z.number().describe(
-    "Unix timestamp (seconds) when the server minted the URL. Use it as the `startedAt` for `wait-for-new-connection` so polling is anchored to server time rather than a possibly-skewed client clock."
-  ),
-  app: zod.z.string().describe(
-    "Versionless app key the URL was minted for (e.g., 'SlackCLIAPI'). Useful for downstream filtering."
-  )
-}).describe(
-  "The signed start-URL plus metadata needed to poll for completion."
-);
+var RecordItemSchema = zod.z.object({
+  id: zod.z.string(),
+  data: zod.z.record(zod.z.string(), zod.z.unknown()),
+  created_at: zod.z.string(),
+  edited_at: zod.z.string(),
+  deleted_at: zod.z.string().nullable().optional()
+});
+var GetTableRecordApiResponseSchema = zod.z.object({
+  data: RecordApiItemSchema
+});
+var GetTableRecordDescription = "Get a single record from a table by ID";
+var GetTableRecordOptionsBaseSchema = zod.z.object({
+  keyMode: KeyModeSchema
+});
+var GetTableRecordOptionsSchema = zod.z.object({
+  table: TablePropertySchema,
+  record: RecordPropertySchema
+}).merge(GetTableRecordOptionsBaseSchema).describe(GetTableRecordDescription).meta({ aliases: { tableId: "table", recordId: "record" } });
+var GetTableRecordOptionsSchemaDeprecated = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  recordId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID").describe("The unique identifier of the record")
+}).merge(GetTableRecordOptionsBaseSchema);
+var GetTableRecordOptionsInputSchema = zod.z.union([GetTableRecordOptionsSchema, GetTableRecordOptionsSchemaDeprecated]).describe(GetTableRecordDescription);
 
-// src/plugins/getConnectionStartUrl/index.ts
-var START_PATH = "/zapier/api/authentications/v1/sdk/connections/start";
-var getConnectionStartUrlPlugin = definePlugin(
-  (sdk) => createPluginMethod(sdk, {
-    name: "getConnectionStartUrl",
-    categories: ["connection"],
-    type: "create",
-    itemType: "ConnectionStartUrl",
-    inputSchema: GetConnectionStartUrlSchema,
-    outputSchema: GetConnectionStartUrlItemSchema,
-    resolvers: { app: appKeyResolver },
-    handler: async ({
-      sdk: inner,
-      options
-    }) => {
-      const versionedKey = await inner.context.getVersionedImplementationId(
-        options.app
-      );
-      const selectedApi = versionedKey ? versionedKey.split("@")[0] : options.app;
-      setMethodMetadata({ selectedApi });
-      const response = await inner.context.api.post(
-        START_PATH,
-        { selected_api: selectedApi },
-        { authRequired: true }
-      );
-      return {
-        data: GetConnectionStartUrlItemSchema.parse({
-          url: response.url,
-          expiresAt: response.expires_at,
-          startedAt: response.started_at,
-          app: selectedApi
-        })
-      };
-    }
+// src/formatters/tableRecord.ts
+var tableRecordFormatter = {
+  fetch: async (sdk, params, item, context) => {
+    if (context) return context;
+    const hasFieldIds = Object.keys(item.data).some(isFieldId);
+    if (!hasFieldIds) return {};
+    const table = params.table ?? params.tableId;
+    if (!table) return {};
+    const { data: fields } = await sdk.listTableFields({ table });
+    return Object.fromEntries(fields.map((f) => [f.id, f.name]));
+  },
+  format: (item, fieldLabels) => ({
+    title: `Record ${item.id}`,
+    id: item.id,
+    details: Object.entries(item.data).map(([k, v]) => ({
+      label: fieldLabels?.[k] ?? k,
+      text: formatFieldValue(v),
+      style: "normal"
+    }))
   })
-);
-var WaitForNewConnectionSchema = zod.z.object({
-  app: AppPropertySchema,
-  startedAt: zod.z.number().int().nonnegative().describe(
-    "Unix timestamp (seconds). Only connections whose `date` is at or after this value count as 'new'. Prefer the `startedAt` returned by `get-connection-start-url` \u2014 it's server-stamped, so the comparison isn't thrown off by client clock skew. If you mint the timestamp yourself, capture it *before* showing the start URL so a fast OAuth completion isn't missed."
-  ),
-  timeoutMs: zod.z.number().int().positive().optional().describe(
-    "How long to wait before giving up. Default 5 minutes (300_000)."
-  ),
-  pollIntervalMs: zod.z.number().int().positive().optional().describe(
-    "Delay before the first poll request, in ms. Default 3 seconds (3_000). Subsequent polling cadence is managed by the SDK's polling primitive (backoff with sane defaults)."
-  )
-}).describe(
-  "Wait for a new connection to appear for the given app. Polls `/api/v0/connections` with server-side `ordering=-date` until the most recent matching row's `date` is at or after the started-at timestamp, then returns it. Pair with `get-connection-start-url` \u2014 that mints the URL the user opens, this waits for the resulting connection to land. Errors with a timeout after the configured timeout (default 5 min). Example (JS):\n\n```ts\nconst { data: { url, app, startedAt } } = await zapier.getConnectionStartUrl({ app: 'slack' });\n// show `url` to the user via the channel they're reading from\nconst { data: conn } = await zapier.waitForNewConnection({ app, startedAt });\n```"
-);
-var WaitForNewConnectionItemSchema = zod.z.object({
-  id: zod.z.string().describe(
-    "The new connection's ID. Public UUID when available, falling back to the numeric ID."
-  ),
-  app: zod.z.string().describe(
-    "Versionless app key the connection was created for (e.g., 'SlackCLIAPI')."
-  ),
-  title: zod.z.string().nullable().optional().describe(
-    "Human-readable connection title set by the auth flow, when available."
-  )
-}).describe("The new connection that was detected.");
+};
 
-// src/plugins/waitForNewConnection/index.ts
-var CONNECTIONS_PATH = "/api/v0/connections";
-var waitForNewConnectionPlugin = definePlugin(
-  (sdk) => createPluginMethod(sdk, {
-    name: "waitForNewConnection",
-    categories: ["connection"],
+// src/plugins/tables/getTableRecord/index.ts
+var getTableRecordPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...tablesDefaults,
+    name: "getTableRecord",
     type: "item",
-    itemType: "Connection",
-    inputSchema: WaitForNewConnectionSchema,
-    outputSchema: WaitForNewConnectionItemSchema,
-    resolvers: { app: appKeyResolver },
-    handler: async ({
-      sdk: inner,
-      options
-    }) => {
-      const versionedKey = await inner.context.getVersionedImplementationId(
-        options.app
+    itemType: "Record",
+    inputSchema: GetTableRecordOptionsInputSchema,
+    outputSchema: RecordItemSchema,
+    resolvers: { table: tableIdResolver, record: tableRecordIdResolver },
+    formatter: tableRecordFormatter,
+    handler: async ({ sdk: sdk2, options }) => {
+      const { api } = sdk2.context;
+      const tableId = "table" in options ? options.table : options.tableId;
+      const recordId = "record" in options ? options.record : options.recordId;
+      const rawResponse = await api.get(
+        `/tables/api/v1/tables/${tableId}/records/${recordId}`,
+        {
+          authRequired: true,
+          resource: { type: "record", id: recordId }
+        }
       );
-      const appKey = versionedKey ? versionedKey.split("@")[0] : options.app;
-      setMethodMetadata({ selectedApi: appKey });
-      try {
-        const top = await inner.context.api.poll(
-          CONNECTIONS_PATH,
-          {
-            searchParams: {
-              app_key: appKey,
-              // Scope to the current user's own connections. The connection
-              // we're waiting on is by definition owned by the caller; without
-              // this the one-row head-check could match a teammate's freshly
-              // created connection for the same app.
-              owner: "me",
-              is_expired: "false",
-              ordering: "-date",
-              page_size: "1"
-            },
-            authRequired: true,
-            timeoutMs: options.timeoutMs ?? 3e5,
-            initialDelay: options.pollIntervalMs ?? 3e3,
-            isPending: (body) => {
-              const rows = body.data ?? [];
-              const head = rows[0];
-              if (!head?.date) return true;
-              const created = Math.floor(new Date(head.date).getTime() / 1e3);
-              return !Number.isFinite(created) || created < options.startedAt;
-            },
-            resultExtractor: (body) => (
-              // `isPending` guaranteed a fresh row at index 0 before this fires.
-              body.data[0]
-            )
-          }
-        );
-        return {
-          data: WaitForNewConnectionItemSchema.parse({
-            id: String(top.public_id ?? top.id),
-            app: appKey,
-            title: top.title ?? null
-          })
-        };
-      } catch (err) {
-        if (err instanceof ZapierTimeoutError) {
-          throw new ZapierTimeoutError(
-            `Timed out waiting for a new "${appKey}" connection. If the user completed the auth flow, retrieve the connection via sdk.getConnection({ id }) with the ID shown on the completion page.`
-          );
+      const response = GetTableRecordApiResponseSchema.parse(rawResponse);
+      const translator = await createFieldKeyTranslator({
+        api,
+        tableId,
+        keyMode: options.keyMode
+      });
+      return {
+        data: {
+          ...transformRecordItem(response.data),
+          data: translator.translateOutput(response.data.data)
         }
-        throw err;
-      }
+      };
     }
   })
 );
+var ListTableRecordsApiResponseSchema = zod.z.object({
+  data: zod.z.array(RecordApiItemSchema),
+  meta: zod.z.object({
+    pagination: zod.z.object({
+      start_cursor: zod.z.string().nullable().optional(),
+      end_cursor: zod.z.string().nullable().optional(),
+      has_more: zod.z.boolean().optional(),
+      has_less: zod.z.boolean().optional()
+    }).optional()
+  }).optional()
+});
+var FilterOperatorSchema = zod.z.enum([
+  "exact",
+  "different",
+  "contains",
+  "icontains",
+  "gte",
+  "gt",
+  "lt",
+  "lte",
+  "range",
+  "in",
+  "isnull",
+  "startswith",
+  "search",
+  "is_within"
+]);
+var FilterConditionSchema = zod.z.object({
+  fieldKey: zod.z.string().describe("The field key to filter on (e.g. f1, f2)"),
+  operator: FilterOperatorSchema.describe("The comparison operator"),
+  value: zod.z.unknown().optional().describe("The value to compare against")
+});
+var SortDirectionSchema = zod.z.enum(["asc", "desc"]);
+var SortConditionSchema = zod.z.object({
+  fieldKey: zod.z.string().describe("The field key to sort by"),
+  direction: SortDirectionSchema.optional().default("asc").describe("Sort direction")
+});
+var ListTableRecordsDescription = "List records in a table with optional filtering and sorting";
+var ListTableRecordsBase = zod.z.object({
+  filters: zod.z.array(FilterConditionSchema).optional().describe("Filter conditions for the query"),
+  sort: SortConditionSchema.optional().describe("Sort records by a field"),
+  pageSize: zod.z.number().min(1).max(1e3).optional().describe("Number of records per page (max 1000)"),
+  maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages"),
+  cursor: zod.z.string().optional().describe("Cursor to start from"),
+  keyMode: KeyModeSchema,
+  trash: TrashSchema
+});
+var ListTableRecordsOptionsSchema = zod.z.object({
+  table: TablePropertySchema
+}).merge(ListTableRecordsBase).describe(ListTableRecordsDescription).meta({ aliases: { tableId: "table" } });
+var ListTableRecordsOptionsSchemaDeprecated = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
+}).merge(ListTableRecordsBase);
+var ListTableRecordsOptionsInputSchema = zod.z.union([
+  ListTableRecordsOptionsSchema,
+  ListTableRecordsOptionsSchemaDeprecated
+]).describe(ListTableRecordsDescription);
 
-// src/utils/should-open-browser.ts
-function shouldOpenBrowser() {
-  if (isCiEnv()) return false;
-  const env = globalThis.process?.env;
-  if (env?.SSH_TTY || env?.SSH_CONNECTION) return false;
-  if (globalThis.process?.platform === "linux" && !env?.DISPLAY && !env?.WAYLAND_DISPLAY) {
-    return false;
-  }
-  return true;
-}
-function isCiEnv() {
-  const env = globalThis.process?.env;
-  return !!(env?.CI || env?.CONTINUOUS_INTEGRATION || env?.GITHUB_ACTIONS || env?.JENKINS_URL || env?.GITLAB_CI || env?.CIRCLECI || env?.TRAVIS || env?.BUILDKITE || env?.DRONE || env?.BITBUCKET_PIPELINES_UUID);
-}
-var CreateConnectionSchema = zod.z.object({
-  app: AppPropertySchema,
-  browser: zod.z.enum(["auto", "always", "never"]).default("auto").describe(
-    "When to auto-open the URL in a browser. `auto` (default) opens in local sessions and skips opening in CI / SSH / headless-Linux. `always` forces the open attempt. `never` skips it. The URL is always printed to stderr regardless \u2014 a failed or skipped open degrades gracefully to copy-paste."
-  ),
-  timeoutMs: zod.z.number().int().positive().optional().describe(
-    "How long to wait for the user to complete the connection flow before giving up. Default 5 minutes (300_000)."
-  ),
-  pollIntervalMs: zod.z.number().int().positive().optional().describe(
-    "Delay before the first poll request, in ms. Default 3 seconds (3_000). Subsequent polling cadence is managed by the SDK's polling primitive (backoff with sane defaults)."
-  )
-}).describe(
-  "Create a new app connection, end-to-end. Mints the start URL via `get-connection-start-url`, prints it to stderr, opportunistically opens it in a browser when it looks safe to do so (skipping CI / SSH / headless-Linux by default \u2014 pass `--browser always` to force, `--browser never` to suppress), then polls via `wait-for-new-connection` until the user completes OAuth and the new connection appears. Returns the connection.\n\nThis is the right command for most callers. Reach for the lower-level building blocks when you want either of: (a) hand off the URL and *not* block on completion \u2014 call `get-connection-start-url` alone, no `wait-for-new-connection` needed, or (b) do something custom between minting the URL and waiting \u2014 call `get-connection-start-url`, do your work (email or DM the URL, render a QR code, etc.), then `wait-for-new-connection`."
-);
-var CreateConnectionItemSchema = zod.z.object({
-  id: zod.z.string().describe(
-    "The new connection's ID. Public UUID when available, falling back to the numeric ID."
-  ),
-  app: zod.z.string().describe(
-    "Versionless app key the connection was created for (e.g., 'SlackCLIAPI')."
-  ),
-  title: zod.z.string().nullable().optional().describe(
-    "Human-readable connection title set by the auth flow, when available."
-  )
-}).describe("The newly created connection.");
+// src/plugins/tables/listTableRecords/index.ts
+var listTableRecordsPlugin = definePlugin(
+  (sdk) => createPaginatedPluginMethod(sdk, {
+    ...tablesDefaults,
+    name: "listTableRecords",
+    type: "list",
+    itemType: "Record",
+    inputSchema: ListTableRecordsOptionsInputSchema,
+    outputSchema: RecordItemSchema,
+    defaultPageSize: DEFAULT_PAGE_SIZE,
+    resolvers: {
+      table: tableIdResolver,
+      filters: tableFiltersResolver,
+      sort: tableSortResolver
+    },
+    formatter: tableRecordFormatter,
+    handler: async ({ sdk: sdk2, options }) => {
+      const { api } = sdk2.context;
+      const tableId = "table" in options ? options.table : options.tableId;
+      const translator = await createFieldKeyTranslator({
+        api,
+        tableId,
+        keyMode: options.keyMode
+      });
+      const body = {};
+      if (options.pageSize !== void 0) {
+        body.limit = options.pageSize;
+      }
+      if (options.filters) {
+        body.filters = options.filters.map((f) => ({
+          key: translator.translateFieldKey(f.fieldKey),
+          operator: f.operator,
+          value: f.value
+        }));
+      }
+      if (options.sort) {
+        body.orders = [
+          {
+            key: translator.translateFieldKey(options.sort.fieldKey),
+            direction: options.sort.direction
+          }
+        ];
+      }
+      if (options.cursor) {
+        body.cursor_query = {
+          query_type: "window",
+          start_cursor: options.cursor
+        };
+      }
+      const searchParams = {
+        allow_nested_queries: "true"
+      };
+      if (options.trash) {
+        searchParams.trash = options.trash;
+      }
+      const rawResponse = await api.post(
+        `/tables/api/v1/tables/${tableId}/records/query`,
+        body,
+        {
+          searchParams,
+          authRequired: true,
+          resource: { type: "table", id: tableId }
+        }
+      );
+      throwOnResponseErrors(rawResponse);
+      const response = ListTableRecordsApiResponseSchema.parse(rawResponse);
+      const pagination = response.meta?.pagination;
+      const nextCursor = pagination?.has_more && pagination.end_cursor ? pagination.end_cursor : void 0;
+      return {
+        data: response.data.map((item) => ({
+          ...transformRecordItem(item),
+          data: translator.translateOutput(item.data)
+        })),
+        nextCursor
+      };
+    }
+  })
+);
+var RecordChangesetSchema = zod.z.object({
+  change_id: zod.z.string(),
+  old: RecordApiItemSchema.nullable(),
+  new: RecordApiItemSchema,
+  changed_field_ids: zod.z.array(zod.z.number()).nullable(),
+  record_id: zod.z.string()
+});
+var CreateTableRecordsApiResponseSchema = zod.z.object({
+  data: zod.z.array(RecordChangesetSchema)
+});
+var NewRecordSchema = zod.z.object({
+  data: zod.z.record(zod.z.string(), zod.z.unknown()).describe("The field values for the record, keyed by field ID")
+});
+var CreateTableRecordsDescription = "Create one or more records in a table";
+var CreateTableRecordsBase = zod.z.object({
+  records: zod.z.array(NewRecordSchema).min(1).max(100).describe("Array of records to create (max 100)"),
+  keyMode: KeyModeSchema
+});
+var CreateTableRecordsOptionsSchema = zod.z.object({
+  table: TablePropertySchema
+}).merge(CreateTableRecordsBase).describe(CreateTableRecordsDescription).meta({ aliases: { tableId: "table" } });
+var CreateTableRecordsOptionsSchemaDeprecated = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
+}).merge(CreateTableRecordsBase);
+var CreateTableRecordsOptionsInputSchema = zod.z.union([
+  CreateTableRecordsOptionsSchema,
+  CreateTableRecordsOptionsSchemaDeprecated
+]).describe(CreateTableRecordsDescription);
 
-// src/plugins/createConnection/index.ts
-var createConnectionPlugin = definePlugin(
+// src/plugins/tables/createTableRecords/index.ts
+var createTableRecordsPlugin = definePlugin(
   (sdk) => createPluginMethod(sdk, {
-    name: "createConnection",
-    categories: ["connection"],
+    ...tablesDefaults,
+    name: "createTableRecords",
     type: "create",
-    itemType: "Connection",
-    inputSchema: CreateConnectionSchema,
-    outputSchema: CreateConnectionItemSchema,
-    resolvers: { app: appKeyResolver },
-    formatter: {
-      format: (item) => ({
-        title: `Connection created: ${item.title || item.id}`,
-        id: item.id,
-        details: [
-          { text: `App: ${item.app}`, style: "normal" },
-          { text: `ID:  ${item.id}`, style: "accent" }
-        ]
-      })
-    },
-    handler: async ({
-      sdk: inner,
-      options
-    }) => {
-      const { data: start } = await inner.getConnectionStartUrl({
-        app: options.app
+    itemType: "Record",
+    returnType: "RecordItem[]",
+    inputSchema: CreateTableRecordsOptionsInputSchema,
+    outputSchema: RecordItemSchema,
+    resolvers: { table: tableIdResolver, records: tableRecordsResolver },
+    formatter: tableRecordFormatter,
+    handler: async ({ sdk: sdk2, options }) => {
+      const { api } = sdk2.context;
+      const tableId = "table" in options ? options.table : options.tableId;
+      const translator = await createFieldKeyTranslator({
+        api,
+        tableId,
+        keyMode: options.keyMode
       });
-      setMethodMetadata({ selectedApi: start.app });
-      console.error(
-        `
-Open this URL to complete the connection:
-  ${start.url}
-`
+      const rawResponse = await api.post(
+        `/tables/api/v1/tables/${tableId}/records`,
+        {
+          new_records: options.records.map((record) => ({
+            data: translator.translateInput(record.data)
+          }))
+        },
+        { authRequired: true, resource: { type: "table", id: tableId } }
       );
-      const shouldOpen = options.browser === "always" || options.browser === "auto" && shouldOpenBrowser();
-      if (shouldOpen) {
-        try {
-          await open_url_default(start.url);
-        } catch {
-        }
+      throwOnResponseErrors(rawResponse);
+      const response = CreateTableRecordsApiResponseSchema.parse(rawResponse);
+      for (const changeset of response.data) {
+        throwOnRecordErrors(changeset.new);
       }
-      const { data: fresh } = await inner.waitForNewConnection({
-        app: start.app,
-        // Server-stamped mint time: measured on the same clock as a
-        // connection's `date`, so the freshness check is immune to
-        // client/server clock skew.
-        startedAt: start.startedAt,
-        timeoutMs: options.timeoutMs,
-        pollIntervalMs: options.pollIntervalMs
-      });
       return {
-        data: CreateConnectionItemSchema.parse({
-          id: fresh.id,
-          app: start.app,
-          title: fresh.title ?? null
-        })
+        data: response.data.map((changeset) => ({
+          ...transformRecordItem(changeset.new),
+          data: translator.translateOutput(changeset.new.data)
+        }))
       };
     }
   })
 );
+var DeleteTableRecordsDescription = "Delete one or more records from a table";
+var DeleteTableRecordsOptionsSchema = zod.z.object({
+  table: TablePropertySchema,
+  records: RecordsPropertySchema
+}).describe(DeleteTableRecordsDescription).meta({ aliases: { tableId: "table", recordIds: "records" } });
+var DeleteTableRecordsOptionsSchemaDeprecated = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  recordIds: zod.z.array(zod.z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID")).min(1).max(100).describe("Array of record IDs to delete (max 100)")
+});
+var DeleteTableRecordsOptionsInputSchema = zod.z.union([
+  DeleteTableRecordsOptionsSchema,
+  DeleteTableRecordsOptionsSchemaDeprecated
+]).describe(DeleteTableRecordsDescription);
 
-// src/plugins/deprecated/authentications.ts
-var listAuthenticationsPlugin = definePlugin(
-  (sdk) => ({
-    listAuthentications: sdk.listConnections,
-    context: {
-      meta: {
-        listAuthentications: {
-          packages: ["cli", "mcp"],
-          categories: ["connection"],
-          deprecation: { message: "Use listConnections instead." },
-          type: "list",
-          itemType: "Connection",
-          inputSchema: ListConnectionsQuerySchema,
-          outputSchema: ConnectionItemSchema,
-          formatter: connectionItemFormatter
-        }
-      }
-    }
-  })
-);
-var getAuthenticationPlugin = definePlugin(
-  (sdk) => ({
-    getAuthentication: sdk.getConnection,
-    context: {
-      meta: {
-        getAuthentication: {
-          packages: ["cli", "mcp"],
-          categories: ["connection"],
-          deprecation: { message: "Use getConnection instead." },
-          type: "item",
-          itemType: "Connection",
-          inputSchema: GetConnectionParamSchema,
-          outputSchema: ConnectionItemSchema,
-          formatter: connectionItemFormatter
+// src/plugins/tables/deleteTableRecords/index.ts
+var deleteTableRecordsPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...tablesDefaults,
+    name: "deleteTableRecords",
+    type: "delete",
+    itemType: "Record",
+    inputSchema: DeleteTableRecordsOptionsInputSchema,
+    resolvers: { table: tableIdResolver, records: tableRecordIdsResolver },
+    confirm: "delete",
+    handler: async ({ sdk: sdk2, options }) => {
+      const tableId = "table" in options ? options.table : options.tableId;
+      const recordIds = "records" in options ? options.records : options.recordIds;
+      await sdk2.context.api.delete(
+        `/tables/api/v1/tables/${tableId}/records`,
+        { record_ids: recordIds },
+        {
+          authRequired: true,
+          resource: { type: "table", id: tableId }
         }
-      }
+      );
+      return { success: true };
     }
   })
 );
-var findFirstAuthenticationPlugin = definePlugin(
-  (sdk) => ({
-    findFirstAuthentication: sdk.findFirstConnection,
-    context: {
-      meta: {
-        findFirstAuthentication: {
-          packages: ["cli", "mcp"],
-          categories: ["connection"],
-          deprecation: { message: "Use findFirstConnection instead." },
-          type: "item",
-          itemType: "Connection",
-          inputSchema: FindFirstConnectionSchema,
-          outputSchema: ConnectionItemSchema,
-          formatter: connectionItemFormatter
-        }
+var RecordChangesetSchema2 = zod.z.object({
+  change_id: zod.z.string(),
+  old: RecordApiItemSchema.nullable(),
+  new: RecordApiItemSchema,
+  changed_field_ids: zod.z.array(zod.z.number()).nullable(),
+  record_id: zod.z.string()
+});
+var UpdateTableRecordsApiResponseSchema = zod.z.object({
+  data: zod.z.array(RecordChangesetSchema2)
+});
+var UpdateRecordSchema = zod.z.object({
+  id: zod.z.string().describe("The record ID to update"),
+  data: zod.z.record(zod.z.string(), zod.z.unknown()).describe("The field values to update, keyed by field key")
+});
+var UpdateTableRecordsDescription = "Update one or more records in a table";
+var UpdateTableRecordsBase = zod.z.object({
+  records: zod.z.array(UpdateRecordSchema).min(1).max(100).describe("Array of records to update (max 100)"),
+  keyMode: KeyModeSchema
+});
+var UpdateTableRecordsOptionsSchema = zod.z.object({
+  table: TablePropertySchema
+}).merge(UpdateTableRecordsBase).describe(UpdateTableRecordsDescription).meta({ aliases: { tableId: "table" } });
+var UpdateTableRecordsOptionsSchemaDeprecated = zod.z.object({
+  tableId: zod.z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
+}).merge(UpdateTableRecordsBase);
+var UpdateTableRecordsOptionsInputSchema = zod.z.union([
+  UpdateTableRecordsOptionsSchema,
+  UpdateTableRecordsOptionsSchemaDeprecated
+]).describe(UpdateTableRecordsDescription);
+
+// src/plugins/tables/updateTableRecords/index.ts
+var updateTableRecordsPlugin = definePlugin(
+  (sdk) => createPluginMethod(sdk, {
+    ...tablesDefaults,
+    name: "updateTableRecords",
+    type: "update",
+    itemType: "Record",
+    returnType: "RecordItem[]",
+    inputSchema: UpdateTableRecordsOptionsInputSchema,
+    outputSchema: RecordItemSchema,
+    resolvers: {
+      table: tableIdResolver,
+      records: tableUpdateRecordsResolver
+    },
+    formatter: tableRecordFormatter,
+    handler: async ({ sdk: sdk2, options }) => {
+      const { api } = sdk2.context;
+      const tableId = "table" in options ? options.table : options.tableId;
+      const translator = await createFieldKeyTranslator({
+        api,
+        tableId,
+        keyMode: options.keyMode
+      });
+      const rawResponse = await api.patch(
+        `/tables/api/v1/tables/${tableId}/records`,
+        {
+          updated_records: options.records.map((record) => ({
+            id: record.id,
+            data: translator.translateInput(record.data)
+          }))
+        },
+        { authRequired: true, resource: { type: "table", id: tableId } }
+      );
+      throwOnResponseErrors(rawResponse);
+      const response = UpdateTableRecordsApiResponseSchema.parse(rawResponse);
+      for (const changeset of response.data) {
+        throwOnRecordErrors(changeset.new);
       }
+      return {
+        data: response.data.map((changeset) => ({
+          ...transformRecordItem(changeset.new),
+          data: translator.translateOutput(changeset.new.data)
+        }))
+      };
     }
   })
 );
-var findUniqueAuthenticationPlugin = definePlugin(
-  (sdk) => ({
-    findUniqueAuthentication: sdk.findUniqueConnection,
-    context: {
-      meta: {
-        findUniqueAuthentication: {
-          packages: ["cli", "mcp"],
-          categories: ["connection"],
-          deprecation: { message: "Use findUniqueConnection instead." },
-          type: "item",
-          itemType: "Connection",
-          inputSchema: FindUniqueConnectionSchema,
-          outputSchema: ConnectionItemSchema,
-          formatter: connectionItemFormatter
-        }
+
+// src/plugins/capabilities/index.ts
+function toDescription(key) {
+  const words = key.replace(/^can/, "").replace(/([A-Z])/g, " $1").trim().toLowerCase();
+  return `To ${words}`;
+}
+function toEnvVar(key) {
+  return "ZAPIER_" + key.replace(/([A-Z])/g, "_$1").toUpperCase();
+}
+function toCliFlag(key) {
+  return "--" + key.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+function buildCapabilityMessage(key) {
+  return [
+    `${toDescription(key)}, use ${toCliFlag(key)} in the CLI,`,
+    `set ${key}: true in SDK options or .zapierrc,`,
+    `or set ${toEnvVar(key)}=true.`
+  ].join(" ");
+}
+var GATED_FLAGS = [
+  "canIncludeSharedConnections",
+  "canIncludeSharedTables",
+  "canDeleteTables"
+];
+function isEnabledByEnv(key) {
+  const value = globalThis.process?.env?.[toEnvVar(key)];
+  if (value === void 0) return void 0;
+  if (value === "true" || value === "1") return true;
+  if (value === "false" || value === "0") return false;
+  return void 0;
+}
+var capabilitiesPlugin = definePlugin(
+  (sdk) => {
+    const options = sdk.context.options ?? {};
+    let cached;
+    async function resolveFlags() {
+      if (cached) return cached;
+      const manifest = await sdk.context.getResolvedManifest();
+      cached = {};
+      for (const flag of GATED_FLAGS) {
+        cached[flag] = Boolean(
+          options[flag] ?? isEnabledByEnv(flag) ?? manifest?.[flag]
+        );
       }
+      return cached;
     }
-  })
-);
-
-// src/plugins/deprecated/inputFields.ts
-var listInputFieldsDeprecatedPlugin = definePlugin(
-  (sdk) => ({
-    listInputFields: sdk.listActionInputFields,
-    context: {
-      meta: {
-        listInputFields: {
-          categories: ["action"],
-          deprecation: { message: "Use listActionInputFields instead." },
-          type: "list",
-          itemType: "RootField",
-          inputSchema: ListActionInputFieldsInputSchema,
-          outputSchema: RootFieldItemSchema,
-          formatter: rootFieldItemFormatter,
-          defaultPageSize: DEFAULT_PAGE_SIZE
+    return {
+      context: {
+        checkCapability: async (key) => {
+          const flags = await resolveFlags();
+          if (flags[key]) return;
+          throw new ZapierConfigurationError(
+            buildCapabilityMessage(key) + " (If you are an AI agent, you MUST NOT retry. Ask the user if they want to enable this.)",
+            { configType: key }
+          );
+        },
+        hasCapability: async (key) => {
+          const flags = await resolveFlags();
+          return flags[key];
         }
       }
-    }
-  })
+    };
+  }
 );
-var listInputFieldChoicesDeprecatedPlugin = definePlugin(
-  (sdk) => ({
-    listInputFieldChoices: sdk.listActionInputFieldChoices,
-    context: {
-      meta: {
-        listInputFieldChoices: {
-          categories: ["action"],
-          deprecation: {
-            message: "Use listActionInputFieldChoices instead."
-          },
-          type: "list",
-          itemType: "InputFieldChoiceItem",
-          inputSchema: ListActionInputFieldChoicesInputSchema,
-          outputSchema: InputFieldChoiceItemSchema,
-          formatter: inputFieldChoiceItemFormatter,
-          defaultPageSize: DEFAULT_PAGE_SIZE
-        }
+
+// src/plugins/connections/index.ts
+var connectionsPlugin = definePlugin(
+  (sdk) => {
+    let cachedMap;
+    async function loadConnectionsMap() {
+      if (cachedMap === void 0) {
+        cachedMap = await sdk.context.getManifestConnections() ?? null;
       }
+      return cachedMap;
     }
-  })
-);
-var getInputFieldsSchemaDeprecatedPlugin = definePlugin(
-  (sdk) => ({
-    getInputFieldsSchema: sdk.getActionInputFieldsSchema,
-    context: {
-      meta: {
-        getInputFieldsSchema: {
-          categories: ["action"],
-          deprecation: { message: "Use getActionInputFieldsSchema instead." },
-          type: "function",
-          inputSchema: GetActionInputFieldsSchemaInputSchema
+    return {
+      context: {
+        resolveConnection: async (name) => {
+          const map = await loadConnectionsMap();
+          return map?.[name];
+        },
+        getConnectionsMap: async () => {
+          return loadConnectionsMap();
         }
       }
-    }
-  })
+    };
+  }
 );
 
 // src/plugins/eventEmission/transport.ts
@@ -10300,12 +11067,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."
@@ -10313,10 +11074,112 @@ 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
+    })
+  );
+}
+
+// src/utils/batch-utils.ts
+var DEFAULT_CONCURRENCY = 10;
+var BATCH_START_DELAY_MS = 25;
+var DEFAULT_BATCH_TIMEOUT_MS = 18e4;
+async function batch(tasks, options = {}) {
+  const {
+    concurrency = DEFAULT_CONCURRENCY,
+    retry = true,
+    batchDelay = BATCH_START_DELAY_MS,
+    timeoutMs = DEFAULT_BATCH_TIMEOUT_MS,
+    taskTimeoutMs
+  } = options;
+  if (concurrency <= 0) {
+    throw new Error("Concurrency must be greater than 0");
+  }
+  if (timeoutMs <= 0) {
+    throw new Error("Timeout must be greater than 0");
+  }
+  if (taskTimeoutMs !== void 0 && taskTimeoutMs <= 0) {
+    throw new Error("Task timeout must be greater than 0");
+  }
+  if (tasks.length === 0) {
+    return [];
+  }
+  const startTime = Date.now();
+  const results = new Array(tasks.length);
+  const taskQueue = tasks.map((task, index) => ({
+    index,
+    task,
+    errorCount: 0
+  }));
+  async function executeTask(taskState) {
+    const { index, task, errorCount } = taskState;
+    try {
+      let result;
+      if (taskTimeoutMs !== void 0) {
+        const timeoutPromise = sleep(taskTimeoutMs).then(() => {
+          throw new ZapierTimeoutError(
+            `Task timed out after ${taskTimeoutMs}ms`
+          );
+        });
+        result = await Promise.race([task(), timeoutPromise]);
+      } else {
+        result = await task();
+      }
+      results[index] = { status: "fulfilled", value: result };
+    } catch (error) {
+      const newErrorCount = errorCount + 1;
+      const isTimeout = error instanceof ZapierTimeoutError;
+      if (retry && !isTimeout && newErrorCount < MAX_CONSECUTIVE_ERRORS) {
+        const waitTime = calculateErrorBackoffMs(1e3, newErrorCount);
+        await sleep(waitTime);
+        taskQueue.push({
+          index,
+          task,
+          errorCount: newErrorCount
+        });
+      } else {
+        results[index] = { status: "rejected", reason: error };
+      }
+    }
+  }
+  async function worker() {
+    while (taskQueue.length > 0) {
+      const elapsedTime = Date.now() - startTime;
+      if (elapsedTime >= timeoutMs) {
+        throw new ZapierTimeoutError(
+          `Batch operation timed out after ${Math.floor(elapsedTime / 1e3)}s. ${taskQueue.length} task(s) not completed.`
+        );
+      }
+      const taskState = taskQueue.shift();
+      if (!taskState) break;
+      await executeTask(taskState);
+      if (taskQueue.length > 0 && batchDelay > 0) {
+        await sleep(batchDelay);
+      }
+    }
+  }
+  const workerCount = Math.min(concurrency, tasks.length);
+  const workers = [];
+  for (let i = 0; i < workerCount; i++) {
+    workers.push(worker());
+    if (i < workerCount - 1 && batchDelay > 0) {
+      await sleep(batchDelay / 10);
+    }
+  }
+  await Promise.all(workers);
+  return results;
 }
 var BaseSdkOptionsSchema = zod.z.object({
   credentials: CredentialsSchema.optional().describe(
@@ -10502,7 +11365,13 @@ exports.createZapierCoreStack = createZapierCoreStack;
 exports.createZapierSdk = createZapierSdk;
 exports.createZapierSdkStack = createZapierSdkStack;
 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;
@@ -10514,6 +11383,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;
@@ -10524,6 +11394,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;
@@ -10601,3 +11472,4 @@ exports.workflowIdResolver = workflowIdResolver;
 exports.workflowRunIdResolver = workflowRunIdResolver;
 exports.workflowVersionIdResolver = workflowVersionIdResolver;
 exports.zapierAdaptError = zapierAdaptError;
+exports.zapierSdkPlugin = zapierSdkPlugin;