@zapier/zapier-sdk 0.77.2 → 0.78.0

package/dist/index.mjs

@@ -50,6 +50,7 @@ function canonicalInputSchema(schema) {
 function buildRegistry({
   sdk,
   meta,
+  formatters,
   packageFilter
 }) {
   const definitionsByKey = /* @__PURE__ */ new Map();
@@ -90,7 +91,7 @@ function buildRegistry({
         (c) => typeof c === "string" ? c : c.key
       ),
       resolvers: m.resolvers,
-      formatter: m.formatter,
+      formatter: formatters?.[key],
       experimental: m.experimental,
       packages: m.packages,
       confirm: m.confirm ?? (m.type === "delete" ? "delete" : void 0),
@@ -516,8 +517,8 @@ function normalizeError(error, adaptError) {
   );
 }
 function createFunction(coreFn, options) {
-  const { sdk, schema } = options;
-  const functionName = coreFn.name;
+  const { sdk, schema, name } = options;
+  const functionName = name || coreFn.name;
   const namedFunctions = {
     [functionName]: async function(callOptions) {
       return runInMethodScope(async () => {
@@ -692,9 +693,6 @@ function createPaginatedFunction(coreFn, options) {
   };
   return namedFunctions[functionName];
 }
-function definePlugin(fn) {
-  return fn;
-}
 function createPluginMethod(sdk, config) {
   const { name, inputSchema, handler, ...metaFields } = config;
   const namedHandlers = {
@@ -763,8 +761,7 @@ function splitPluginContribution(result) {
 }
 var RESERVED_ROOT_KEYS = /* @__PURE__ */ new Set([
   "context",
-  "getRegistry",
-  "addPlugin"
+  "getRegistry"
 ]);
 function hasOwn(obj, key) {
   return Object.prototype.hasOwnProperty.call(obj, key);
@@ -778,15 +775,28 @@ function setOwn(target, key, value) {
   });
 }
 function checkCollisions(target, source, kind, callerLabel, override) {
+  if (kind === "root key") {
+    checkRootKeyCollisions(target, Object.keys(source), override, callerLabel);
+    return;
+  }
   for (const key of Object.keys(source)) {
-    if (kind === "root key" && RESERVED_ROOT_KEYS.has(key)) {
+    if (!override && hasOwn(target, key)) {
+      throw new Error(
+        `${callerLabel}: duplicate ${kind} "${key}". If the override is intentional, pass { override: true } in the options.`
+      );
+    }
+  }
+}
+function checkRootKeyCollisions(target, keys, override, callerLabel) {
+  for (const key of keys) {
+    if (RESERVED_ROOT_KEYS.has(key)) {
       throw new Error(
         `${callerLabel}: plugin attempted to register reserved root key "${key}". The SDK uses this key for its own accessor; rename the plugin's method.`
       );
     }
     if (!override && hasOwn(target, key)) {
       throw new Error(
-        `${callerLabel}: duplicate ${kind} "${key}". If the override is intentional, pass { override: true } in the options.`
+        `${callerLabel}: duplicate root key "${key}". If the override is intentional, pass { override: true } in the options.`
       );
     }
   }
@@ -837,7 +847,7 @@ function mergeContribution(propertiesTarget, contextTarget, contribution, option
 function applyPluginContribution(acc, contribution, options) {
   mergeContribution(acc.view, acc.context, contribution, options);
 }
-function wrapAsSdk(properties, context, opts) {
+function wrapAsSdk(properties, context) {
   const sdk = {
     ...properties,
     context,
@@ -849,9 +859,6 @@ function wrapAsSdk(properties, context, opts) {
       });
     }
   };
-  if (opts?.addPlugin !== void 0) {
-    sdk.addPlugin = opts.addPlugin;
-  }
   return sdk;
 }
 function wrapAccumulatorAsSdk(acc) {
@@ -870,126 +877,92 @@ function applyPluginToSdk(sdk, plugin, options) {
     callerLabel: "addPlugin",
     override: options.override === true
   });
+  return contribution;
 }
-function buildStackAccumulator(head, callerLabel) {
-  const ordered = [];
+function resolveStack(head) {
+  const entries = [];
   let node = head;
   while (node) {
-    ordered.unshift(node);
+    entries.unshift({ apply: node.entry, override: node.override });
     node = node.prev;
   }
-  const acc = createPluginAccumulator();
-  for (const { plugin, override } of ordered) {
-    const contribution = splitPluginContribution(
-      plugin(acc.view)
-    );
-    applyPluginContribution(acc, contribution, { callerLabel, override });
-  }
-  return acc;
-}
-function addPlugin(sdk, plugin, options) {
-  applyPluginToSdk(
-    sdk,
-    plugin,
-    options ?? {}
-  );
+  return entries;
+}
+function composeStackHooks(hooks) {
+  let composed = {};
+  for (const h of hooks) composed = buildHooks(composed, h);
+  return composed;
+}
+function collapseStackEntries(entries, callerLabel) {
+  return (outerSdk) => {
+    const { context: outerContext, ...outerProperties } = outerSdk ?? {};
+    const viewAcc = createPluginAccumulator(outerProperties, outerContext);
+    const contribsAcc = createPluginAccumulator();
+    const hooks = [];
+    for (const { apply, override } of entries) {
+      const contribution = splitPluginContribution(
+        apply(viewAcc.view)
+      );
+      const hookless = { ...contribution, hooks: {} };
+      applyPluginContribution(viewAcc, hookless, { callerLabel, override });
+      applyPluginContribution(contribsAcc, hookless, { callerLabel, override });
+      hooks.push(contribution.hooks);
+    }
+    const stackHooks = composeStackHooks(hooks);
+    viewAcc.context.hooks = buildHooks(viewAcc.context.hooks, stackHooks);
+    contribsAcc.context.hooks = stackHooks;
+    const { context: _ignored, ...contributedRoot } = contribsAcc.view;
+    return {
+      ...contributedRoot,
+      context: contribsAcc.context
+    };
+  };
 }
-function buildSdk(properties, context) {
-  const addPlugin2 = (plugin, options) => {
-    logDeprecation(
-      "sdk.addPlugin(plugin) (the chain-style extension) is deprecated. Build the SDK in one pass with createPluginStack().use(...).toSdk() instead \u2014 each .toSdk() produces fresh plugin closures and avoids the closure-sharing semantics that caused this to be deprecated."
-    );
+function buildStackAccumulator(head, callerLabel) {
+  const entries = resolveStack(head);
+  const acc = createPluginAccumulator();
+  const hooks = [];
+  for (const { apply, override } of entries) {
     const contribution = splitPluginContribution(
-      plugin({ ...properties, context })
+      apply(acc.view)
     );
-    const mergedProperties = { ...properties };
-    const mergedContext = {
-      ...context,
-      meta: { ...context.meta },
-      hooks: { ...context.hooks }
-    };
-    mergeContribution(mergedProperties, mergedContext, contribution, {
-      callerLabel: "addPlugin",
-      override: options?.override === true
-    });
-    return buildSdk(
-      mergedProperties,
-      mergedContext
+    applyPluginContribution(
+      acc,
+      { ...contribution, hooks: {} },
+      { callerLabel, override }
     );
-  };
-  return wrapAsSdk(properties, context, { addPlugin: addPlugin2 });
-}
-function withDeprecatedAddPlugin(sdk) {
-  const initialProperties = {};
-  for (const key of Object.keys(sdk)) {
-    if (key === "context" || key === "getRegistry" || key === "addPlugin") {
-      continue;
-    }
-    initialProperties[key] = sdk[key];
+    hooks.push(contribution.hooks);
   }
-  const initialContext = sdk.context;
-  return buildSdk(
-    initialProperties,
-    initialContext
-  );
+  acc.context.hooks = composeStackHooks(hooks);
+  return acc;
 }
 function composePlugins(...plugins) {
   logDeprecation(
-    "composePlugins(...) is deprecated. Use createPluginStack().use(a).use(b).use(c).toPlugin() instead. The stack carries the same collision-detection and hook-composition behavior, supports per-step { override: true } for intentional duplicates, and progressively narrows types so dependency mistakes surface at the specific .use call."
-  );
-  let stack = buildPluginStack(
-    null,
-    "composePlugins"
+    "composePlugins(...) is deprecated. Use createPluginStack().use(a).use(b).use(c).toPlugin({ name }) instead. The stack carries the same collision-detection and hook-composition behavior and supports per-step { override: true } for intentional duplicates."
   );
+  let head = null;
   for (const plugin of plugins) {
-    stack = stack.use(plugin);
+    head = { entry: plugin, override: false, prev: head };
   }
-  return stack.toPlugin();
+  const entries = resolveStack(head);
+  return collapseStackEntries(entries, "composePlugins");
 }
 function createPluginStack() {
   return buildPluginStack(null, "createPluginStack");
 }
 function buildPluginStack(head, callerLabel) {
-  return {
+  const stack = {
     use(plugin, options) {
       const next = {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        plugin,
+        entry: plugin,
         override: options?.override === true,
         prev: head
       };
       return buildPluginStack(next, callerLabel);
     },
     toPlugin() {
-      const ordered = [];
-      let node = head;
-      while (node) {
-        ordered.unshift(node);
-        node = node.prev;
-      }
-      return (outerSdk) => {
-        const { context: outerContext, ...outerProperties } = outerSdk ?? {};
-        const viewAcc = createPluginAccumulator(outerProperties, outerContext);
-        const contribsAcc = createPluginAccumulator();
-        for (const { plugin: subPlugin, override } of ordered) {
-          const contribution = splitPluginContribution(
-            subPlugin(viewAcc.view)
-          );
-          applyPluginContribution(viewAcc, contribution, {
-            callerLabel,
-            override
-          });
-          applyPluginContribution(contribsAcc, contribution, {
-            callerLabel,
-            override
-          });
-        }
-        const { context: _ignored, ...contributedRoot } = contribsAcc.view;
-        return {
-          ...contributedRoot,
-          context: contribsAcc.context
-        };
-      };
+      const entries = resolveStack(head);
+      return collapseStackEntries(entries, callerLabel);
     },
     toSdk() {
       return wrapAccumulatorAsSdk(
@@ -997,419 +970,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 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 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: z.object({ package: z.string().optional() }).optional(),
+  run: ({ imports, input }) => buildSurfaceRegistry(imports.context, input?.package)
+});
+function normalizeOutput(output) {
+  if (output === void 0) return { type: "raw" };
+  if (typeof output === "string") return { type: output };
+  return output;
 }
-var 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(
-  z.string().min(1).describe("App key (e.g., 'SlackCLIAPI' or slug like 'github')")
-);
-var AppPropertySchema = withPositional(
-  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 = 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 = z.string().min(1).describe("Action key to execute");
-var ActionPropertySchema = withPositional(
-  z.string().min(1).describe("Action key (e.g., 'send_message' or 'find_row')")
-);
-var InputFieldPropertySchema = withPositional(
-  z.string().min(1).describe("Input field key to get choices for")
-);
-var ConnectionIdPropertySchema = z.union([z.string(), z.number().int().positive()]).describe("Connection ID to use for this action");
-var AuthenticationIdPropertySchema = ConnectionIdPropertySchema.meta({
-  deprecated: true
-});
-var ConnectionPropertySchema = z.union([z.string(), 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 = z.record(z.string(), z.unknown()).describe("Input parameters for the action");
-var LimitPropertySchema = z.number().int().min(1).max(MAX_PAGE_LIMIT).default(50).describe("Maximum number of items to return");
-var OffsetPropertySchema = z.number().int().min(0).default(0).describe("Number of items to skip for pagination");
-var OutputPropertySchema = z.string().describe("Output file path");
-var DebugPropertySchema = z.boolean().default(false).describe("Enable debug logging");
-var ParamsPropertySchema = z.record(z.string(), z.unknown()).describe("Additional parameters");
-var ActionTimeoutMsPropertySchema = z.number().min(1e3).optional().describe(
-  `Maximum time to wait for action completion in milliseconds (default: ${DEFAULT_ACTION_TIMEOUT_MS})`
-);
-var TablePropertySchema = withPositional(
-  z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
-);
-var RecordPropertySchema = withPositional(
-  z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID").describe("The unique identifier of the record")
-);
-var RecordsPropertySchema = z.array(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 = z.array(z.union([z.string(), z.number()])).describe(
-  'Fields to operate on. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
-);
-var AppsPropertySchema = z.array(z.string()).describe("Filter by app keys (e.g., 'SlackCLIAPI' or slug like 'github')");
-var TablesPropertySchema = z.array(z.string()).describe("Filter by specific table IDs");
-var ConnectionsPropertySchema = z.array(z.string()).describe("List of connection IDs to filter by");
-var TriggerInboxPropertySchema = withPositional(
-  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 = z.string().min(1).max(100).describe(
-  "Inbox name; unique per (user, account). Enables get-or-create on createTriggerInbox."
-);
-var LeasePropertySchema = z.string().min(1).describe("Lease ID returned from leaseTriggerInboxMessages");
-var LeaseSecondsPropertySchema = 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 = 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 z.ZodOptional) {
+    return isPositional(schema._zod.def.innerType);
   }
-  if (error instanceof ZapierApprovalError && error.approvalUrl) {
-    message += `
-Approval URL: ${error.approvalUrl}`;
+  if (schema instanceof 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(
+  z.string().min(1).describe("App key (e.g., 'SlackCLIAPI' or slug like 'github')")
+);
+var AppPropertySchema = withPositional(
+  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 = 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 = z.string().min(1).describe("Action key to execute");
+var ActionPropertySchema = withPositional(
+  z.string().min(1).describe("Action key (e.g., 'send_message' or 'find_row')")
+);
+var InputFieldPropertySchema = withPositional(
+  z.string().min(1).describe("Input field key to get choices for")
+);
+var ConnectionIdPropertySchema = z.union([z.string(), z.number().int().positive()]).describe("Connection ID to use for this action");
+var AuthenticationIdPropertySchema = ConnectionIdPropertySchema.meta({
+  deprecated: true
+});
+var ConnectionPropertySchema = z.union([z.string(), 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 = z.record(z.string(), z.unknown()).describe("Input parameters for the action");
+var LimitPropertySchema = z.number().int().min(1).max(MAX_PAGE_LIMIT).default(50).describe("Maximum number of items to return");
+var OffsetPropertySchema = z.number().int().min(0).default(0).describe("Number of items to skip for pagination");
+var OutputPropertySchema = z.string().describe("Output file path");
+var DebugPropertySchema = z.boolean().default(false).describe("Enable debug logging");
+var ParamsPropertySchema = z.record(z.string(), z.unknown()).describe("Additional parameters");
+var ActionTimeoutMsPropertySchema = z.number().min(1e3).optional().describe(
+  `Maximum time to wait for action completion in milliseconds (default: ${DEFAULT_ACTION_TIMEOUT_MS})`
+);
+var TablePropertySchema = withPositional(
+  z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table")
+);
+var RecordPropertySchema = withPositional(
+  z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID").describe("The unique identifier of the record")
+);
+var RecordsPropertySchema = z.array(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 = z.array(z.union([z.string(), z.number()])).describe(
+  'Fields to operate on. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
+);
+var AppsPropertySchema = z.array(z.string()).describe("Filter by app keys (e.g., 'SlackCLIAPI' or slug like 'github')");
+var TablesPropertySchema = z.array(z.string()).describe("Filter by specific table IDs");
+var ConnectionsPropertySchema = z.array(z.string()).describe("List of connection IDs to filter by");
+var TriggerInboxPropertySchema = withPositional(
+  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 = z.string().min(1).max(100).describe(
+  "Inbox name; unique per (user, account). Enables get-or-create on createTriggerInbox."
+);
+var LeasePropertySchema = z.string().min(1).describe("Lease ID returned from leaseTriggerInboxMessages");
+var LeaseSecondsPropertySchema = 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 = 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 = z.object({
@@ -4896,7 +5754,7 @@ var actionResultItemFormatter = {
       id: getStringProperty(obj, "id"),
       key: getStringProperty(obj, "key"),
       description: getStringProperty(obj, "description"),
-      data: item,
+      raw: item,
       details: []
     };
   }
@@ -5645,8 +6503,10 @@ var UserProfileItemSchema = 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" });
@@ -5659,41 +6519,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) {
@@ -6995,7 +7852,7 @@ function parseApprovalReviewStreamPayload(parsed, toolNames) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.77.2" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.78.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -8240,182 +9097,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 = 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 = z.object({
+  url: z.string().describe(
+    "URL the user should open in their browser to complete the auth flow. Single-use, time-limited."
+  ),
+  expiresAt: z.number().describe(
+    "Unix timestamp (seconds) after which the URL's signature is rejected by zapier.com."
+  ),
+  startedAt: 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: 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 = z.object({
+  app: AppPropertySchema,
+  startedAt: 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: z.number().int().positive().optional().describe(
+    "How long to wait before giving up. Default 5 minutes (300_000)."
+  ),
+  pollIntervalMs: 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 = z.object({
+  id: z.string().describe(
+    "The new connection's ID. Public UUID when available, falling back to the numeric ID."
+  ),
+  app: z.string().describe(
+    "Versionless app key the connection was created for (e.g., 'SlackCLIAPI')."
+  ),
+  title: 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 = z.object({
+  app: AppPropertySchema,
+  browser: 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: 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: 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 = z.object({
+  id: z.string().describe(
+    "The new connection's ID. Public UUID when available, falling back to the numeric ID."
+  ),
+  app: z.string().describe(
+    "Versionless app key the connection was created for (e.g., 'SlackCLIAPI')."
+  ),
+  title: 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 = z.object({
   id: z.string(),
@@ -8532,256 +9608,67 @@ var listTablesPlugin = definePlugin(
     }
   })
 );
-var GetTableApiResponseSchema = z.object({
-  data: TableApiItemSchema
-});
-var GetTableDescription = "Get detailed information about a specific table";
-var GetTableOptionsSchema = z.object({
-  table: TablePropertySchema
-}).describe(GetTableDescription).meta({ aliases: { tableId: "table" } });
-var GetTableOptionsSchemaDeprecated = z.object({
-  tableId: 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 = 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 = z.object({
-  data: TableApiItemSchema
-});
-var CreateTableOptionsSchema = z.object({
-  name: z.string().min(1).describe("The name for the new table"),
-  description: 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 = z.object({
-  table: TablePropertySchema
-}).describe(DeleteTableDescription).meta({ aliases: { tableId: "table" } });
-var DeleteTableOptionsSchemaDeprecated = z.object({
-  tableId: 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 = 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 = z.object({
-  new: FieldApiItemSchema,
-  old: FieldApiItemSchema.nullable(),
-  kind: z.enum(["created", "updated", "deleted"])
-});
-var CreateTableFieldsApiResponseSchema = z.object({
-  data: z.array(FieldChangesetItemSchema),
-  meta: z.object({
-    did_change: z.boolean()
-  }).optional()
-});
-var NewFieldSchema = z.object({
-  type: FieldTypeSchema.describe("The data type of the field"),
-  name: z.string().min(1).describe("The display name of the field"),
-  options: z.record(z.string(), z.unknown()).optional().describe("Data configuration options for the field"),
-  config: z.record(z.string(), z.unknown()).optional().describe("Display configuration for the field")
-});
-var CreateTableFieldsDescription = "Create one or more fields in a table";
-var CreateTableFieldsBase = z.object({
-  fields: z.array(NewFieldSchema).min(1).describe("Array of field definitions to create")
+var GetTableApiResponseSchema = z.object({
+  data: TableApiItemSchema
 });
-var CreateTableFieldsOptionsSchema = z.object({
+var GetTableDescription = "Get detailed information about a specific table";
+var GetTableOptionsSchema = z.object({
   table: TablePropertySchema
-}).merge(CreateTableFieldsBase).describe(CreateTableFieldsDescription).meta({ aliases: { tableId: "table" } });
-var CreateTableFieldsOptionsSchemaDeprecated = z.object({
-  tableId: 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 = z.union([
-  CreateTableFieldsOptionsSchema,
-  CreateTableFieldsOptionsSchemaDeprecated
-]).describe(CreateTableFieldsDescription);
+}).describe(GetTableDescription).meta({ aliases: { tableId: "table" } });
+var GetTableOptionsSchemaDeprecated = z.object({
+  tableId: 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 = 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 = z.object({
-  table: TablePropertySchema,
-  fields: FieldsPropertySchema.min(1)
-}).describe(DeleteTableFieldsDescription).meta({ aliases: { tableId: "table", fieldKeys: "fields" } });
-var DeleteTableFieldsOptionsSchemaDeprecated = z.object({
-  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
-  fieldKeys: z.array(z.union([z.string(), 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 = z.object({
+  table: TablePropertySchema
+}).describe(DeleteTableDescription).meta({ aliases: { tableId: "table" } });
+var DeleteTableOptionsSchemaDeprecated = z.object({
+  tableId: 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 = z.union([
-  DeleteTableFieldsOptionsSchema,
-  DeleteTableFieldsOptionsSchemaDeprecated
-]).describe(DeleteTableFieldsDescription);
+var DeleteTableOptionsInputSchema = 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 }
@@ -8791,820 +9678,700 @@ var deleteTableFieldsPlugin = definePlugin(
     }
   })
 );
-var RecordApiItemSchema = z.object({
-  id: z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID"),
-  data: z.record(z.string(), z.unknown()),
-  created_at: z.string(),
-  edited_at: z.string(),
-  schema_revision_id: z.number(),
-  errors: z.record(z.string(), z.unknown()).nullable().optional(),
-  orig_data: z.record(z.string(), z.unknown()).nullable().optional(),
-  is_source_record: z.boolean().nullable().optional(),
-  deleted_at: z.string().nullable().optional()
-});
-var RecordItemSchema = z.object({
-  id: z.string(),
-  data: z.record(z.string(), z.unknown()),
-  created_at: z.string(),
-  edited_at: z.string(),
-  deleted_at: z.string().nullable().optional()
-});
-var GetTableRecordApiResponseSchema = z.object({
-  data: RecordApiItemSchema
-});
-var GetTableRecordDescription = "Get a single record from a table by ID";
-var GetTableRecordOptionsBaseSchema = z.object({
-  keyMode: KeyModeSchema
-});
-var GetTableRecordOptionsSchema = z.object({
-  table: TablePropertySchema,
-  record: RecordPropertySchema
-}).merge(GetTableRecordOptionsBaseSchema).describe(GetTableRecordDescription).meta({ aliases: { tableId: "table", recordId: "record" } });
-var GetTableRecordOptionsSchemaDeprecated = z.object({
-  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
-  recordId: 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 = 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 = z.object({
-  data: z.array(RecordApiItemSchema),
-  meta: z.object({
-    pagination: z.object({
-      start_cursor: z.string().nullable().optional(),
-      end_cursor: z.string().nullable().optional(),
-      has_more: z.boolean().optional(),
-      has_less: z.boolean().optional()
-    }).optional()
-  }).optional()
-});
-var FilterOperatorSchema = z.enum([
-  "exact",
-  "different",
-  "contains",
-  "icontains",
-  "gte",
-  "gt",
-  "lt",
-  "lte",
-  "range",
-  "in",
-  "isnull",
-  "startswith",
-  "search",
-  "is_within"
-]);
-var FilterConditionSchema = z.object({
-  fieldKey: z.string().describe("The field key to filter on (e.g. f1, f2)"),
-  operator: FilterOperatorSchema.describe("The comparison operator"),
-  value: z.unknown().optional().describe("The value to compare against")
-});
-var SortDirectionSchema = z.enum(["asc", "desc"]);
-var SortConditionSchema = z.object({
-  fieldKey: 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 = z.object({
-  filters: z.array(FilterConditionSchema).optional().describe("Filter conditions for the query"),
-  sort: SortConditionSchema.optional().describe("Sort records by a field"),
-  pageSize: z.number().min(1).max(1e3).optional().describe("Number of records per page (max 1000)"),
-  maxItems: z.number().min(1).optional().describe("Maximum total items to return across all pages"),
-  cursor: z.string().optional().describe("Cursor to start from"),
-  keyMode: KeyModeSchema,
-  trash: TrashSchema
+var CreateTableApiResponseSchema = z.object({
+  data: TableApiItemSchema
 });
-var ListTableRecordsOptionsSchema = z.object({
-  table: TablePropertySchema
-}).merge(ListTableRecordsBase).describe(ListTableRecordsDescription).meta({ aliases: { tableId: "table" } });
-var ListTableRecordsOptionsSchemaDeprecated = z.object({
-  tableId: 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 = z.union([
-  ListTableRecordsOptionsSchema,
-  ListTableRecordsOptionsSchemaDeprecated
-]).describe(ListTableRecordsDescription);
+var CreateTableOptionsSchema = z.object({
+  name: z.string().min(1).describe("The name for the new table"),
+  description: 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 = z.object({
-  change_id: z.string(),
-  old: RecordApiItemSchema.nullable(),
-  new: RecordApiItemSchema,
-  changed_field_ids: z.array(z.number()).nullable(),
-  record_id: z.string()
+var FieldChangesetItemSchema = z.object({
+  new: FieldApiItemSchema,
+  old: FieldApiItemSchema.nullable(),
+  kind: z.enum(["created", "updated", "deleted"])
 });
-var CreateTableRecordsApiResponseSchema = z.object({
-  data: z.array(RecordChangesetSchema)
+var CreateTableFieldsApiResponseSchema = z.object({
+  data: z.array(FieldChangesetItemSchema),
+  meta: z.object({
+    did_change: z.boolean()
+  }).optional()
 });
-var NewRecordSchema = z.object({
-  data: z.record(z.string(), z.unknown()).describe("The field values for the record, keyed by field ID")
+var NewFieldSchema = z.object({
+  type: FieldTypeSchema.describe("The data type of the field"),
+  name: z.string().min(1).describe("The display name of the field"),
+  options: z.record(z.string(), z.unknown()).optional().describe("Data configuration options for the field"),
+  config: z.record(z.string(), z.unknown()).optional().describe("Display configuration for the field")
 });
-var CreateTableRecordsDescription = "Create one or more records in a table";
-var CreateTableRecordsBase = z.object({
-  records: 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 = z.object({
+  fields: z.array(NewFieldSchema).min(1).describe("Array of field definitions to create")
 });
-var CreateTableRecordsOptionsSchema = z.object({
+var CreateTableFieldsOptionsSchema = z.object({
   table: TablePropertySchema
-}).merge(CreateTableRecordsBase).describe(CreateTableRecordsDescription).meta({ aliases: { tableId: "table" } });
-var CreateTableRecordsOptionsSchemaDeprecated = z.object({
+}).merge(CreateTableFieldsBase).describe(CreateTableFieldsDescription).meta({ aliases: { tableId: "table" } });
+var CreateTableFieldsOptionsSchemaDeprecated = z.object({
   tableId: 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 = z.union([
-  CreateTableRecordsOptionsSchema,
-  CreateTableRecordsOptionsSchemaDeprecated
-]).describe(CreateTableRecordsDescription);
+}).merge(CreateTableFieldsBase);
+var CreateTableFieldsOptionsInputSchema = 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 = z.object({
-  table: TablePropertySchema,
-  records: RecordsPropertySchema
-}).describe(DeleteTableRecordsDescription).meta({ aliases: { tableId: "table", recordIds: "records" } });
-var DeleteTableRecordsOptionsSchemaDeprecated = z.object({
-  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
-  recordIds: z.array(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 = 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 = z.object({
-  change_id: z.string(),
-  old: RecordApiItemSchema.nullable(),
-  new: RecordApiItemSchema,
-  changed_field_ids: z.array(z.number()).nullable(),
-  record_id: z.string()
-});
-var UpdateTableRecordsApiResponseSchema = z.object({
-  data: z.array(RecordChangesetSchema2)
-});
-var UpdateRecordSchema = z.object({
-  id: z.string().describe("The record ID to update"),
-  data: z.record(z.string(), z.unknown()).describe("The field values to update, keyed by field key")
-});
-var UpdateTableRecordsDescription = "Update one or more records in a table";
-var UpdateTableRecordsBase = z.object({
-  records: 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 = z.object({
+  table: TablePropertySchema,
+  fields: FieldsPropertySchema.min(1)
+}).describe(DeleteTableFieldsDescription).meta({ aliases: { tableId: "table", fieldKeys: "fields" } });
+var DeleteTableFieldsOptionsSchemaDeprecated = z.object({
+  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  fieldKeys: z.array(z.union([z.string(), z.number()])).min(1).describe(
+    'Fields to delete. Accepts field names (e.g., "Email") or IDs (e.g., "f6", "6", or 6).'
+  )
 });
-var UpdateTableRecordsOptionsSchema = z.object({
-  table: TablePropertySchema
-}).merge(UpdateTableRecordsBase).describe(UpdateTableRecordsDescription).meta({ aliases: { tableId: "table" } });
-var UpdateTableRecordsOptionsSchemaDeprecated = z.object({
-  tableId: 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 = z.union([
-  UpdateTableRecordsOptionsSchema,
-  UpdateTableRecordsOptionsSchemaDeprecated
-]).describe(UpdateTableRecordsDescription);
+var DeleteTableFieldsOptionsInputSchema = 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 = z.object({
+  id: z.string().regex(/^[A-Z0-9]{26}$/, "Record ID must be a valid ULID"),
+  data: z.record(z.string(), z.unknown()),
+  created_at: z.string(),
+  edited_at: z.string(),
+  schema_revision_id: z.number(),
+  errors: z.record(z.string(), z.unknown()).nullable().optional(),
+  orig_data: z.record(z.string(), z.unknown()).nullable().optional(),
+  is_source_record: z.boolean().nullable().optional(),
+  deleted_at: z.string().nullable().optional()
 });
-function createZapierCoreStack() {
-  return createPluginStack().use(zapierCorePlugin);
-}
-var GetConnectionStartUrlSchema = 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 = z.object({
-  url: z.string().describe(
-    "URL the user should open in their browser to complete the auth flow. Single-use, time-limited."
-  ),
-  expiresAt: z.number().describe(
-    "Unix timestamp (seconds) after which the URL's signature is rejected by zapier.com."
-  ),
-  startedAt: 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: 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 = z.object({
+  id: z.string(),
+  data: z.record(z.string(), z.unknown()),
+  created_at: z.string(),
+  edited_at: z.string(),
+  deleted_at: z.string().nullable().optional()
+});
+var GetTableRecordApiResponseSchema = z.object({
+  data: RecordApiItemSchema
+});
+var GetTableRecordDescription = "Get a single record from a table by ID";
+var GetTableRecordOptionsBaseSchema = z.object({
+  keyMode: KeyModeSchema
+});
+var GetTableRecordOptionsSchema = z.object({
+  table: TablePropertySchema,
+  record: RecordPropertySchema
+}).merge(GetTableRecordOptionsBaseSchema).describe(GetTableRecordDescription).meta({ aliases: { tableId: "table", recordId: "record" } });
+var GetTableRecordOptionsSchemaDeprecated = z.object({
+  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  recordId: 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 = 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 = z.object({
-  app: AppPropertySchema,
-  startedAt: 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: z.number().int().positive().optional().describe(
-    "How long to wait before giving up. Default 5 minutes (300_000)."
-  ),
-  pollIntervalMs: 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 = z.object({
-  id: z.string().describe(
-    "The new connection's ID. Public UUID when available, falling back to the numeric ID."
-  ),
-  app: z.string().describe(
-    "Versionless app key the connection was created for (e.g., 'SlackCLIAPI')."
-  ),
-  title: 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 = z.object({
+  data: z.array(RecordApiItemSchema),
+  meta: z.object({
+    pagination: z.object({
+      start_cursor: z.string().nullable().optional(),
+      end_cursor: z.string().nullable().optional(),
+      has_more: z.boolean().optional(),
+      has_less: z.boolean().optional()
+    }).optional()
+  }).optional()
+});
+var FilterOperatorSchema = z.enum([
+  "exact",
+  "different",
+  "contains",
+  "icontains",
+  "gte",
+  "gt",
+  "lt",
+  "lte",
+  "range",
+  "in",
+  "isnull",
+  "startswith",
+  "search",
+  "is_within"
+]);
+var FilterConditionSchema = z.object({
+  fieldKey: z.string().describe("The field key to filter on (e.g. f1, f2)"),
+  operator: FilterOperatorSchema.describe("The comparison operator"),
+  value: z.unknown().optional().describe("The value to compare against")
+});
+var SortDirectionSchema = z.enum(["asc", "desc"]);
+var SortConditionSchema = z.object({
+  fieldKey: 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 = z.object({
+  filters: z.array(FilterConditionSchema).optional().describe("Filter conditions for the query"),
+  sort: SortConditionSchema.optional().describe("Sort records by a field"),
+  pageSize: z.number().min(1).max(1e3).optional().describe("Number of records per page (max 1000)"),
+  maxItems: z.number().min(1).optional().describe("Maximum total items to return across all pages"),
+  cursor: z.string().optional().describe("Cursor to start from"),
+  keyMode: KeyModeSchema,
+  trash: TrashSchema
+});
+var ListTableRecordsOptionsSchema = z.object({
+  table: TablePropertySchema
+}).merge(ListTableRecordsBase).describe(ListTableRecordsDescription).meta({ aliases: { tableId: "table" } });
+var ListTableRecordsOptionsSchemaDeprecated = z.object({
+  tableId: 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 = 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 = z.object({
-  app: AppPropertySchema,
-  browser: 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: 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: 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 = z.object({
-  id: z.string().describe(
-    "The new connection's ID. Public UUID when available, falling back to the numeric ID."
-  ),
-  app: z.string().describe(
-    "Versionless app key the connection was created for (e.g., 'SlackCLIAPI')."
-  ),
-  title: 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 = z.object({
+  change_id: z.string(),
+  old: RecordApiItemSchema.nullable(),
+  new: RecordApiItemSchema,
+  changed_field_ids: z.array(z.number()).nullable(),
+  record_id: z.string()
+});
+var CreateTableRecordsApiResponseSchema = z.object({
+  data: z.array(RecordChangesetSchema)
+});
+var NewRecordSchema = z.object({
+  data: z.record(z.string(), 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 = z.object({
+  records: z.array(NewRecordSchema).min(1).max(100).describe("Array of records to create (max 100)"),
+  keyMode: KeyModeSchema
+});
+var CreateTableRecordsOptionsSchema = z.object({
+  table: TablePropertySchema
+}).merge(CreateTableRecordsBase).describe(CreateTableRecordsDescription).meta({ aliases: { tableId: "table" } });
+var CreateTableRecordsOptionsSchemaDeprecated = z.object({
+  tableId: 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 = 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 = z.object({
+  table: TablePropertySchema,
+  records: RecordsPropertySchema
+}).describe(DeleteTableRecordsDescription).meta({ aliases: { tableId: "table", recordIds: "records" } });
+var DeleteTableRecordsOptionsSchemaDeprecated = z.object({
+  tableId: z.string().regex(/^[A-Z0-9]{26}$/, "Table ID must be a valid ULID").describe("The unique identifier of the table"),
+  recordIds: z.array(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 = 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 = z.object({
+  change_id: z.string(),
+  old: RecordApiItemSchema.nullable(),
+  new: RecordApiItemSchema,
+  changed_field_ids: z.array(z.number()).nullable(),
+  record_id: z.string()
+});
+var UpdateTableRecordsApiResponseSchema = z.object({
+  data: z.array(RecordChangesetSchema2)
+});
+var UpdateRecordSchema = z.object({
+  id: z.string().describe("The record ID to update"),
+  data: z.record(z.string(), z.unknown()).describe("The field values to update, keyed by field key")
+});
+var UpdateTableRecordsDescription = "Update one or more records in a table";
+var UpdateTableRecordsBase = z.object({
+  records: z.array(UpdateRecordSchema).min(1).max(100).describe("Array of records to update (max 100)"),
+  keyMode: KeyModeSchema
+});
+var UpdateTableRecordsOptionsSchema = z.object({
+  table: TablePropertySchema
+}).merge(UpdateTableRecordsBase).describe(UpdateTableRecordsDescription).meta({ aliases: { tableId: "table" } });
+var UpdateTableRecordsOptionsSchemaDeprecated = z.object({
+  tableId: 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 = 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
@@ -10298,12 +11065,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."
@@ -10311,10 +11072,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 = z.object({
   credentials: CredentialsSchema.optional().describe(
@@ -10386,4 +11249,4 @@ var registryPlugin = definePlugin((_sdk) => {
   return {};
 });
 
-export { ActionKeyPropertySchema, ActionPropertySchema, ActionTimeoutMsPropertySchema, ActionTypePropertySchema, AppKeyPropertySchema, AppPropertySchema, AppsPropertySchema, AuthMechanism, AuthenticationIdPropertySchema, BaseSdkOptionsSchema, CONTEXT_CACHE_MAX_SIZE, CONTEXT_CACHE_TTL_MS, CORE_ERROR_SYMBOL, ClientCredentialsObjectSchema, ConnectionEntrySchema, ConnectionIdPropertySchema, ConnectionPropertySchema, ConnectionsMapSchema, ConnectionsPropertySchema, CoreErrorCode, CredentialsFunctionSchema, CredentialsObjectSchema, CredentialsSchema, DEFAULT_ACTION_TIMEOUT_MS, DEFAULT_APPROVAL_TIMEOUT_MS, DEFAULT_CONFIG_PATH, DEFAULT_MAX_APPROVAL_RETRIES, DEFAULT_PAGE_SIZE, DebugPropertySchema, FieldsPropertySchema, InputFieldPropertySchema, InputsPropertySchema, LeaseLimitPropertySchema, LeasePropertySchema, LeaseSecondsPropertySchema, LimitPropertySchema, MAX_CONCURRENCY_LIMIT, MAX_PAGE_LIMIT, OffsetPropertySchema, OutputPropertySchema, ParamsPropertySchema, PkceCredentialsObjectSchema, RecordPropertySchema, RecordsPropertySchema, RelayFetchSchema, RelayRequestSchema, ResolvedCredentialsSchema, TablePropertySchema, TablesPropertySchema, TriggerInboxNamePropertySchema, TriggerInboxPropertySchema, ZAPIER_BASE_URL, ZAPIER_MAX_CONCURRENT_REQUESTS, ZAPIER_MAX_NETWORK_RETRIES, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, ZapierAbortDrainSignal, ZapierActionError, ZapierApiError, ZapierAppNotFoundError, ZapierApprovalError, ZapierAuthenticationError, ZapierBundleError, ZapierConfigurationError, ZapierConflictError, ZapierError, ZapierNotFoundError, ZapierRateLimitError, ZapierRelayError, ZapierReleaseTriggerMessageSignal, ZapierResourceNotFoundError, ZapierSignal, ZapierTimeoutError, ZapierUnknownError, ZapierValidationError, actionKeyResolver, actionTypeResolver, addPlugin, apiPlugin, appKeyResolver, appsPlugin, connectionIdGenericResolver as authenticationIdGenericResolver, connectionIdResolver as authenticationIdResolver, batch, buildApplicationLifecycleEvent, buildCapabilityMessage, buildErrorEvent, buildErrorEventWithContext, buildMethodCalledEvent, cleanupEventListeners, clearTokenCache, clientCredentialsNameResolver, clientIdResolver, composePlugins, connectionIdGenericResolver, connectionIdResolver, connectionsPlugin, createBaseEvent, createClientCredentialsPlugin, createCorePlugin, createFunction, createMemoryCache, createOptionsPlugin, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createSdk, createTableFieldsPlugin, createTablePlugin, createTableRecordsPlugin, createZapierApi, createZapierCoreStack, createZapierSdk, createZapierSdkStack, createZapierSdkWithoutRegistry, definePlugin, deleteClientCredentialsPlugin, deleteTableFieldsPlugin, deleteTablePlugin, deleteTableRecordsPlugin, durableRunIdResolver, eventEmissionPlugin, fetchPlugin, findFirstConnectionPlugin, findManifestEntry, findUniqueConnectionPlugin, formatErrorMessage, generateEventId, getActionInputFieldsSchemaPlugin, getActionPlugin, getAgent, getAppPlugin, getBaseUrlFromCredentials, getCallerContext, getCiPlatform, getClientIdFromCredentials, getConnectionPlugin, getCoreErrorCause, getCoreErrorCode, getCpuTime, getCurrentTimestamp, getMemoryUsage, getOrCreateApiClient, getOsInfo, getPlatformVersions, getPreferredManifestEntryKey, getProfilePlugin, getReleaseId, getTablePlugin, getTableRecordPlugin, getTokenFromCliLogin, getTtyContext, getZapierApprovalMode, getZapierDefaultApprovalMode, getZapierOpenAutoModeApprovalsInBrowser, getZapierSdkService, injectCliLogin, inputFieldKeyResolver, inputsAllOptionalResolver, inputsResolver, invalidateCachedToken, invalidateCredentialsToken, isCi, isCliLoginAvailable, isClientCredentials, isCoreError, isCredentialsFunction, isCredentialsObject, isPermanentHttpError, isPkceCredentials, isPositional, listActionInputFieldChoicesPlugin, listActionInputFieldsPlugin, listActionsPlugin, listAppsPlugin, listClientCredentialsPlugin, listConnectionsPlugin, listTableFieldsPlugin, listTableRecordsPlugin, listTablesPlugin, logDeprecation2 as logDeprecation, manifestPlugin, parseConcurrencyEnvVar, readManifestFromFile, registryPlugin, requestPlugin, resetDeprecationWarnings2 as resetDeprecationWarnings, resolveAuth, resolveAuthToken, resolveCredentials, resolveCredentialsFromEnv, runActionPlugin, runInMethodScope, runWithCallerContext, runWithTelemetryContext, tableFieldIdsResolver, tableFieldsResolver, tableFiltersResolver, tableIdResolver, tableNameResolver, tableRecordIdResolver, tableRecordIdsResolver, tableRecordsResolver, tableSortResolver, tableUpdateRecordsResolver, toSnakeCase, toTitleCase, triggerInboxResolver, triggerMessagesResolver, updateTableRecordsPlugin, workflowIdResolver, workflowRunIdResolver, workflowVersionIdResolver, zapierAdaptError };
+export { ActionKeyPropertySchema, ActionPropertySchema, ActionTimeoutMsPropertySchema, ActionTypePropertySchema, AppKeyPropertySchema, AppPropertySchema, AppsPropertySchema, AuthMechanism, AuthenticationIdPropertySchema, BaseSdkOptionsSchema, CONTEXT_CACHE_MAX_SIZE, CONTEXT_CACHE_TTL_MS, CORE_ERROR_SYMBOL, ClientCredentialsObjectSchema, ConnectionEntrySchema, ConnectionIdPropertySchema, ConnectionPropertySchema, ConnectionsMapSchema, ConnectionsPropertySchema, CoreErrorCode, CredentialsFunctionSchema, CredentialsObjectSchema, CredentialsSchema, DEFAULT_ACTION_TIMEOUT_MS, DEFAULT_APPROVAL_TIMEOUT_MS, DEFAULT_CONFIG_PATH, DEFAULT_MAX_APPROVAL_RETRIES, DEFAULT_PAGE_SIZE, DebugPropertySchema, FieldsPropertySchema, InputFieldPropertySchema, InputsPropertySchema, LeaseLimitPropertySchema, LeasePropertySchema, LeaseSecondsPropertySchema, LimitPropertySchema, MAX_CONCURRENCY_LIMIT, MAX_PAGE_LIMIT, OffsetPropertySchema, OutputPropertySchema, ParamsPropertySchema, PkceCredentialsObjectSchema, RecordPropertySchema, RecordsPropertySchema, RelayFetchSchema, RelayRequestSchema, ResolvedCredentialsSchema, TablePropertySchema, TablesPropertySchema, TriggerInboxNamePropertySchema, TriggerInboxPropertySchema, ZAPIER_BASE_URL, ZAPIER_MAX_CONCURRENT_REQUESTS, ZAPIER_MAX_NETWORK_RETRIES, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, ZapierAbortDrainSignal, ZapierActionError, ZapierApiError, ZapierAppNotFoundError, ZapierApprovalError, ZapierAuthenticationError, ZapierBundleError, ZapierConfigurationError, ZapierConflictError, ZapierError, ZapierNotFoundError, ZapierRateLimitError, ZapierRelayError, ZapierReleaseTriggerMessageSignal, ZapierResourceNotFoundError, ZapierSignal, ZapierTimeoutError, ZapierUnknownError, ZapierValidationError, actionKeyResolver, actionTypeResolver, addPlugin, apiPlugin, appKeyResolver, appsPlugin, connectionIdGenericResolver as authenticationIdGenericResolver, connectionIdResolver as authenticationIdResolver, batch, buildApplicationLifecycleEvent, buildCapabilityMessage, buildErrorEvent, buildErrorEventWithContext, buildMethodCalledEvent, cleanupEventListeners, clearTokenCache, clientCredentialsNameResolver, clientIdResolver, composePlugins, connectionIdGenericResolver, connectionIdResolver, connectionsPlugin, createBaseEvent, createClientCredentialsPlugin, createCorePlugin, createFunction, createMemoryCache, createOptionsPlugin, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createSdk, createTableFieldsPlugin, createTablePlugin, createTableRecordsPlugin, createZapierApi, createZapierCoreStack, createZapierSdk, createZapierSdkStack, createZapierSdkWithoutRegistry, dangerousContextPlugin, declareMethod, declareProperty, defineLegacyMerge, defineMethod, definePlugin, defineProperty, deleteClientCredentialsPlugin, deleteTableFieldsPlugin, deleteTablePlugin, deleteTableRecordsPlugin, durableRunIdResolver, eventEmissionPlugin, fetchPlugin, findFirstConnectionPlugin, findManifestEntry, findUniqueConnectionPlugin, formatErrorMessage, fromFunctionPlugin, generateEventId, getActionInputFieldsSchemaPlugin, getActionPlugin, getAgent, getAppPlugin, getBaseUrlFromCredentials, getCallerContext, getCiPlatform, getClientIdFromCredentials, getConnectionPlugin, getContext, getCoreErrorCause, getCoreErrorCode, getCpuTime, getCurrentTimestamp, getMemoryUsage, getOrCreateApiClient, getOsInfo, getPlatformVersions, getPreferredManifestEntryKey, getProfilePlugin, getReleaseId, getTablePlugin, getTableRecordPlugin, getTokenFromCliLogin, getTtyContext, getZapierApprovalMode, getZapierDefaultApprovalMode, getZapierOpenAutoModeApprovalsInBrowser, getZapierSdkService, injectCliLogin, inputFieldKeyResolver, inputsAllOptionalResolver, inputsResolver, invalidateCachedToken, invalidateCredentialsToken, isCi, isCliLoginAvailable, isClientCredentials, isCoreError, isCredentialsFunction, isCredentialsObject, isPermanentHttpError, isPkceCredentials, isPositional, listActionInputFieldChoicesPlugin, listActionInputFieldsPlugin, listActionsPlugin, listAppsPlugin, listClientCredentialsPlugin, listConnectionsPlugin, listTableFieldsPlugin, listTableRecordsPlugin, listTablesPlugin, logDeprecation2 as logDeprecation, manifestPlugin, parseConcurrencyEnvVar, readManifestFromFile, registryPlugin, requestPlugin, resetDeprecationWarnings2 as resetDeprecationWarnings, resolveAuth, resolveAuthToken, resolveCredentials, resolveCredentialsFromEnv, runActionPlugin, runInMethodScope, runWithCallerContext, runWithTelemetryContext, tableFieldIdsResolver, tableFieldsResolver, tableFiltersResolver, tableIdResolver, tableNameResolver, tableRecordIdResolver, tableRecordIdsResolver, tableRecordsResolver, tableSortResolver, tableUpdateRecordsResolver, toSnakeCase, toTitleCase, triggerInboxResolver, triggerMessagesResolver, updateTableRecordsPlugin, workflowIdResolver, workflowRunIdResolver, workflowVersionIdResolver, zapierAdaptError, zapierSdkPlugin };