@zapier/zapier-sdk 0.85.0 → 0.86.0

package/dist/index.mjs

@@ -32,6 +32,33 @@ function pluralizeLastWord(title) {
   const words = title.split(" ");
   return [...words.slice(0, -1), pluralize(words[words.length - 1])].join(" ");
 }
+function canonicalInputSchema(schema) {
+  if (schema instanceof z.ZodUnion) {
+    return schema.options[0];
+  }
+  return schema;
+}
+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 (schema instanceof z.ZodOptional) {
+    return isPositional(schema._zod.def.innerType);
+  }
+  if (schema instanceof z.ZodDefault) {
+    return isPositional(schema._zod.def.innerType);
+  }
+  return false;
+}
 function resolveCategoryDefinition(ref) {
   const def = typeof ref === "string" ? { key: ref } : ref;
   const title = def.title ?? toTitleCase(def.key);
@@ -41,30 +68,25 @@ function resolveCategoryDefinition(ref) {
     titlePlural: def.titlePlural ?? pluralizeLastWord(title)
   };
 }
-function canonicalInputSchema(schema) {
-  if (schema instanceof z.ZodUnion) {
-    return schema.options[0];
-  }
-  return schema;
-}
 function buildRegistry({
   sdk,
   meta,
   formatters,
-  boundResolvers,
+  resolvers,
   positional,
+  skipInputValidation,
   packageFilter
 }) {
   const definitionsByKey = /* @__PURE__ */ new Map();
   const objectDeclaredKeys = /* @__PURE__ */ new Set();
   for (const m of Object.values(meta)) {
     for (const ref of m.categories ?? []) {
-      const key2 = typeof ref === "string" ? ref : ref.key;
+      const key = typeof ref === "string" ? ref : ref.key;
       if (typeof ref === "object") {
-        objectDeclaredKeys.add(key2);
-        definitionsByKey.set(key2, resolveCategoryDefinition(ref));
-      } else if (!objectDeclaredKeys.has(key2)) {
-        definitionsByKey.set(key2, resolveCategoryDefinition(ref));
+        objectDeclaredKeys.add(key);
+        definitionsByKey.set(key, resolveCategoryDefinition(ref));
+      } else if (!objectDeclaredKeys.has(key)) {
+        definitionsByKey.set(key, resolveCategoryDefinition(ref));
       }
     }
   }
@@ -72,30 +94,29 @@ function buildRegistry({
     definitionsByKey.set("other", resolveCategoryDefinition("other"));
   }
   const knownCategories = Array.from(definitionsByKey.keys());
-  const functions = Object.keys(meta).filter((key2) => {
-    const property = sdk[key2];
+  const functions = Object.keys(meta).filter((key) => {
+    const property = sdk[key];
     if (typeof property === "function") return true;
-    const [rootKey] = key2.split(".");
+    const [rootKey] = key.split(".");
     const rootProperty = sdk[rootKey];
     return typeof rootProperty === "object" && rootProperty !== null;
-  }).map((key2) => {
-    const m = meta[key2];
+  }).map((key) => {
+    const m = meta[key];
     return {
-      name: key2,
+      name: key,
       description: m.description,
       type: m.type,
       itemType: m.itemType,
       returnType: m.returnType,
       inputSchema: canonicalInputSchema(m.inputSchema),
-      inputParameters: m.inputParameters,
       outputSchema: m.outputSchema,
-      positional: positional?.[key2],
+      positional: positional?.[key],
+      skipInputValidation: skipInputValidation?.[key],
       categories: (m.categories ?? []).map(
         (c) => typeof c === "string" ? c : c.key
       ),
-      resolvers: m.resolvers,
-      boundResolvers: boundResolvers?.[key2],
-      formatter: formatters?.[key2],
+      resolvers: resolvers?.[key],
+      formatter: formatters?.[key],
       experimental: m.experimental,
       packages: m.packages,
       confirm: m.confirm ?? (m.type === "delete" ? "delete" : void 0),
@@ -510,6 +531,50 @@ function runInMethodScope(fn) {
   return scope.run({ depth: currentDepth + 1 }, fn);
 }
 var runWithTelemetryContext = runInMethodScope;
+var CALL_CONTEXT_BRAND = Symbol("kitcore.callContext");
+function isCallContext(value) {
+  return typeof value === "object" && value !== null && value[CALL_CONTEXT_BRAND] === true;
+}
+function generateCallId() {
+  try {
+    const webCrypto = globalThis.crypto;
+    if (webCrypto?.randomUUID) {
+      return webCrypto.randomUUID();
+    }
+    if (webCrypto?.getRandomValues) {
+      const bytes = webCrypto.getRandomValues(new Uint8Array(16));
+      const hex = Array.from(bytes, (byte, i) => {
+        const value = i === 6 ? byte & 15 | 64 : i === 8 ? byte & 63 | 128 : byte;
+        return value.toString(16).padStart(2, "0");
+      });
+      return [
+        hex.slice(0, 4).join(""),
+        hex.slice(4, 6).join(""),
+        hex.slice(6, 8).join(""),
+        hex.slice(8, 10).join(""),
+        hex.slice(10, 16).join("")
+      ].join("-");
+    }
+  } catch {
+  }
+  return null;
+}
+function rootCallContext() {
+  return {
+    callId: generateCallId(),
+    depth: 0,
+    annotations: {},
+    [CALL_CONTEXT_BRAND]: true
+  };
+}
+function childCallContext(parent) {
+  return {
+    callId: parent.callId,
+    depth: parent.depth + 1,
+    annotations: {},
+    [CALL_CONTEXT_BRAND]: true
+  };
+}
 function defaultLogDeprecation({
   methodName,
   deprecation
@@ -525,6 +590,9 @@ function resolveCoreOptions(context) {
   return context.core;
 }
 var INTERNAL_CALL = Symbol("kitcore.internalCall");
+function resolveCallContext(secondArg) {
+  return isCallContext(secondArg) ? secondArg : rootCallContext();
+}
 function signalDeprecation(context, methodName, getDeprecation) {
   if (isInsideObserver()) return;
   const deprecation = getDeprecation?.();
@@ -554,14 +622,16 @@ function createFunction(coreFn, options) {
   const functionName = name || coreFn.name;
   const namedFunctions = {
     [functionName]: async function(callOptions) {
-      if (arguments[1] !== INTERNAL_CALL) {
+      const internal = arguments[1];
+      const context = resolveCallContext(internal);
+      if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
         signalDeprecation(sdk.context, functionName, getDeprecation);
       }
       return runInMethodScope(async () => {
         const startTime = Date.now();
         const normalizedOptions = callOptions ?? {};
         const args = [normalizedOptions];
-        const depth = getCurrentDepth();
+        const depth = Math.max(context.depth, getCurrentDepth());
         const hooks = isInsideObserver() ? void 0 : sdk.context.hooks;
         const adaptError = resolveCoreOptions(sdk.context)?.adaptError;
         hooks?.onMethodStart?.({
@@ -580,12 +650,15 @@ function createFunction(coreFn, options) {
                 adaptError
               }
             );
-            result = await coreFn({
-              ...normalizedOptions,
-              ...validatedOptions
-            });
+            result = await coreFn(
+              {
+                ...normalizedOptions,
+                ...validatedOptions
+              },
+              context
+            );
           } else {
-            result = await coreFn(normalizedOptions);
+            result = await coreFn(normalizedOptions, context);
           }
           hooks?.onMethodEnd?.({
             methodName: functionName,
@@ -615,17 +688,19 @@ function createFunction(coreFn, options) {
 function createRawFunction(coreFn, options) {
   const { sdk, name, schema, positional, getDeprecation } = options;
   return function(rawInput) {
-    if (arguments[1] !== INTERNAL_CALL) {
+    const internal = arguments[1];
+    const context = resolveCallContext(internal);
+    if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
       signalDeprecation(sdk.context, name, getDeprecation);
     }
     return runInMethodScope(() => {
       const startTime = Date.now();
-      const depth = getCurrentDepth();
+      const depth = Math.max(context.depth, getCurrentDepth());
       const hooks = isInsideObserver() ? void 0 : sdk.context.hooks;
       const adaptError = resolveCoreOptions(sdk.context)?.adaptError;
       const input = schema ? rawInput ?? {} : rawInput;
       const record = input;
-      const args = positional ? positional.filter((key2) => record?.[key2] !== void 0).map((key2) => record?.[key2]) : [input];
+      const args = positional ? positional.filter((key) => record?.[key] !== void 0).map((key) => record?.[key]) : [input];
       hooks?.onMethodStart?.({
         methodName: name,
         args,
@@ -644,7 +719,7 @@ function createRawFunction(coreFn, options) {
       };
       try {
         const parsed = schema ? validateOptions(schema, input, { adaptError }) : input;
-        const result = coreFn(parsed);
+        const result = coreFn(parsed, context);
         if (result !== null && typeof result === "object" && typeof result.then === "function") {
           return result.then(
             (value) => {
@@ -683,9 +758,9 @@ function createPageFunction(coreFn, {
 }) {
   const functionName = coreFn.name + "Page";
   const namedFunctions = {
-    [functionName]: async function(options) {
+    [functionName]: async function(options, callContext) {
       try {
-        const response = await coreFn(options);
+        const response = await coreFn(options, callContext);
         const page = adaptPage ? adaptPage(response) : response;
         if (!isSdkPage(page)) {
           throw new Error(
@@ -709,14 +784,16 @@ function createPaginatedFunction(coreFn, options) {
   const functionName = name || coreFn.name;
   const namedFunctions = {
     [functionName]: function(callOptions) {
-      if (arguments[1] !== INTERNAL_CALL) {
+      const internal = arguments[1];
+      const context = resolveCallContext(internal);
+      if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
         signalDeprecation(sdk.context, functionName, getDeprecation);
       }
       return runInMethodScope(() => {
         const startTime = Date.now();
         const normalizedOptions = callOptions ?? {};
         const args = [normalizedOptions];
-        const depth = getCurrentDepth();
+        const depth = Math.max(context.depth, getCurrentDepth());
         const hooks = isInsideObserver() ? void 0 : sdk.context.hooks;
         const adaptError = resolveCoreOptions(sdk.context)?.adaptError;
         hooks?.onMethodStart?.({
@@ -735,7 +812,11 @@ function createPaginatedFunction(coreFn, options) {
             ...validatedOptions,
             pageSize
           };
-          const iterator = paginate(pageFunction, optimizedOptions);
+          const iterator = paginate(
+            (pageOptions) => pageFunction(pageOptions, context),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            optimizedOptions
+          );
           const firstPagePromise = iterator.next().then((result) => {
             if (result.done) {
               throw new Error("Paginate should always iterate at least once");
@@ -884,11 +965,11 @@ var RESERVED_ROOT_KEYS = /* @__PURE__ */ new Set([
   "context",
   "getRegistry"
 ]);
-function hasOwn(obj, key2) {
-  return Object.prototype.hasOwnProperty.call(obj, key2);
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
 }
-function setOwn(target, key2, value) {
-  Object.defineProperty(target, key2, {
+function setOwn(target, key, value) {
+  Object.defineProperty(target, key, {
     value,
     enumerable: true,
     configurable: true,
@@ -900,31 +981,31 @@ function checkCollisions(target, source, kind, callerLabel, override) {
     checkRootKeyCollisions(target, Object.keys(source), override, callerLabel);
     return;
   }
-  for (const key2 of Object.keys(source)) {
-    if (!override && hasOwn(target, key2)) {
+  for (const key of Object.keys(source)) {
+    if (!override && hasOwn(target, key)) {
       throw new Error(
-        `${callerLabel}: duplicate ${kind} "${key2}". If the override is intentional, pass { override: true } in the options.`
+        `${callerLabel}: duplicate ${kind} "${key}". If the override is intentional, pass { override: true } in the options.`
       );
     }
   }
 }
 function checkRootKeyCollisions(target, keys, override, callerLabel) {
-  for (const key2 of keys) {
-    if (RESERVED_ROOT_KEYS.has(key2)) {
+  for (const key of keys) {
+    if (RESERVED_ROOT_KEYS.has(key)) {
       throw new Error(
-        `${callerLabel}: plugin attempted to register reserved root key "${key2}". The SDK uses this key for its own accessor; rename the plugin's method.`
+        `${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, key2)) {
+    if (!override && hasOwn(target, key)) {
       throw new Error(
-        `${callerLabel}: duplicate root key "${key2}". 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.`
       );
     }
   }
 }
 function applyOwnProperties(target, source) {
-  for (const key2 of Object.keys(source)) {
-    setOwn(target, key2, source[key2]);
+  for (const key of Object.keys(source)) {
+    setOwn(target, key, source[key]);
   }
 }
 function createPluginAccumulator(initialProperties = {}, initialContext = {}) {
@@ -1138,7 +1219,6 @@ var LEAF_META_KEYS = [
   "itemType",
   "returnType",
   "outputSchema",
-  "inputParameters",
   "packages",
   "experimental",
   "confirm",
@@ -1175,8 +1255,8 @@ function normalizeImports(deps) {
 }
 function collectLeafMeta(config) {
   let meta;
-  for (const key2 of LEAF_META_KEYS) {
-    if (config[key2] !== void 0) (meta ?? (meta = {}))[key2] = config[key2];
+  for (const key of LEAF_META_KEYS) {
+    if (config[key] !== void 0) (meta ?? (meta = {}))[key] = config[key];
   }
   return meta;
 }
@@ -1259,7 +1339,8 @@ function defineResolver(config) {
         type: "object",
         properties: config.properties,
         definitions: config.definitions,
-        getProperties: config.getProperties
+        getProperties: config.getProperties,
+        additionalKeys: config.additionalKeys
       };
     case "array":
       return {
@@ -1562,7 +1643,7 @@ function normalizeFormatter(entry, sdk) {
   const legacy = entry.meta?.formatter;
   return legacy ? adaptLegacyFormatter(legacy, sdk) : void 0;
 }
-function normalizeBoundResolvers(entry) {
+function normalizeResolvers(entry) {
   if (entry.pluginType !== "method") return void 0;
   return entry.resolvers;
 }
@@ -1603,17 +1684,20 @@ function collectSurfaceProjection(context, formatterSdk) {
     foldDynamicMembers(entry, surfaceBindings, meta);
   }
   const formatters = {};
-  const boundResolvers = {};
+  const resolvers = {};
   const positional = {};
+  const skipInputValidation = {};
   for (const [binding, entry] of Object.entries(entries)) {
     const f = normalizeFormatter(entry, formatterSdk);
     if (f) formatters[binding] = f;
-    const r = normalizeBoundResolvers(entry);
-    if (r) boundResolvers[binding] = r;
+    const r = normalizeResolvers(entry);
+    if (r) resolvers[binding] = r;
     const p = methodPositional(entry);
     if (p) positional[binding] = p;
+    if (entry.pluginType === "method" && entry.skipInputValidation)
+      skipInputValidation[binding] = true;
   }
-  return { meta, formatters, boundResolvers, positional };
+  return { meta, formatters, resolvers, positional, skipInputValidation };
 }
 function buildSurfaceRegistry(context, packageFilter) {
   const surface = {};
@@ -1666,6 +1750,11 @@ function nestedResolvers(resolver) {
     for (const field of Object.values(resolver.properties ?? {})) {
       if (!isResolverRef(field.resolver)) out.push(field.resolver);
     }
+    const ak = resolver.additionalKeys;
+    if (ak) {
+      if (!isResolverRef(ak.values)) out.push(ak.values);
+      if (ak.keys && !isResolverRef(ak.keys)) out.push(ak.keys);
+    }
     out.push(...Object.values(resolver.definitions ?? {}));
   } else if (resolver.type === "array") {
     if (!isResolverRef(resolver.items)) out.push(resolver.items);
@@ -1790,16 +1879,16 @@ function collectPlugins(root, materialized = /* @__PURE__ */ new Set(), configur
   }
   return byId;
 }
-function bindValue(target, key2, entry, callType = "surface") {
+function bindValue(target, key, entry, callType = "surface", ctx) {
   if (entry.pluginType === "property" && entry.getValue) {
-    Object.defineProperty(target, key2, {
+    Object.defineProperty(target, key, {
       get: entry.getValue,
       enumerable: true,
       configurable: true
     });
   } else {
-    const value = callType === "internal" && entry.pluginType === "method" ? entry.internalValue ?? entry.value : entry.value;
-    Object.defineProperty(target, key2, {
+    const value = callType === "internal" && entry.pluginType === "method" ? entry.bindInternal?.(ctx) ?? entry.internalValue ?? entry.value : entry.value;
+    Object.defineProperty(target, key, {
       value,
       writable: true,
       enumerable: true,
@@ -1816,7 +1905,7 @@ function buildSurface(context, ...maps) {
   sdk[CONTEXT] = context;
   return sdk;
 }
-function buildImports(plugins, importBindings) {
+function buildImports(plugins, importBindings, ctx) {
   const imports = {};
   for (const { binding, id, optional } of importBindings) {
     const entry = plugins[id];
@@ -1829,7 +1918,7 @@ function buildImports(plugins, importBindings) {
       });
       continue;
     }
-    bindValue(imports, binding, entry, "internal");
+    bindValue(imports, binding, entry, "internal", ctx);
   }
   return imports;
 }
@@ -1908,6 +1997,19 @@ function bindResolver(resolver, plugins) {
       const { getProperties } = resolver;
       if (getProperties)
         bound.getProperties = ({ input }) => getProperties({ imports, input });
+      if (resolver.additionalKeys) {
+        const ak = resolver.additionalKeys;
+        const boundAk = {
+          values: isResolverRef(ak.values) ? ak.values : bindResolver(ak.values, plugins),
+          minEntries: ak.minEntries,
+          maxEntries: ak.maxEntries,
+          keyValueType: ak.keyValueType,
+          valueValueType: ak.valueValueType
+        };
+        if (ak.keys)
+          boundAk.keys = isResolverRef(ak.keys) ? ak.keys : bindResolver(ak.keys, plugins);
+        bound.additionalKeys = boundAk;
+      }
       return bound;
     }
     case "array": {
@@ -1963,8 +2065,8 @@ function bindResolver(resolver, plugins) {
 }
 function bindFields(fields, plugins) {
   const out = {};
-  for (const [key2, field] of Object.entries(fields)) {
-    out[key2] = {
+  for (const [key, field] of Object.entries(fields)) {
+    out[key] = {
       ...field,
       resolver: isResolverRef(field.resolver) ? field.resolver : bindResolver(field.resolver, plugins)
     };
@@ -1973,8 +2075,8 @@ function bindFields(fields, plugins) {
 }
 function bindDefinitions(definitions, plugins) {
   const out = {};
-  for (const [key2, def] of Object.entries(definitions)) {
-    out[key2] = bindResolver(def, plugins);
+  for (const [key, def] of Object.entries(definitions)) {
+    out[key] = bindResolver(def, plugins);
   }
   return out;
 }
@@ -2058,6 +2160,7 @@ function buildMethodEntries(descriptors, context, states) {
       name: descriptor.name,
       chain: [],
       inputSchema: descriptor.inputSchema,
+      skipInputValidation: descriptor.skipInputValidation,
       // 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 },
@@ -2065,17 +2168,17 @@ function buildMethodEntries(descriptors, context, states) {
       // Replaced below; never called.
       value: () => void 0
     };
-    const callRun = (input) => descriptor.run({
-      imports: buildImports(plugins, descriptor.importBindings),
+    const callRun = (input, ctx) => descriptor.run({
+      imports: buildImports(plugins, descriptor.importBindings, ctx),
       state: states.get(id),
       input
     });
-    const fold = (coreFn) => (input) => {
-      let next = coreFn;
+    const fold = (coreFn) => (input, ctx) => {
+      let next = (i) => coreFn(i, ctx);
       for (const wrap of entry.chain) {
         const inner = next;
         next = (i) => wrap.run({
-          imports: buildImports(plugins, wrap.owner.importBindings),
+          imports: buildImports(plugins, wrap.owner.importBindings, ctx),
           next: inner,
           input: i,
           // Overwritten by the chain item's own closure with the owning
@@ -2099,7 +2202,7 @@ function buildMethodEntries(descriptors, context, states) {
         }
       );
     } else if (out.type === "item") {
-      const itemCore = async (input) => callRun(input);
+      const itemCore = async (input, ctx) => callRun(input, ctx);
       entry.value = createFunction(
         fold(itemCore),
         {
@@ -2111,7 +2214,7 @@ function buildMethodEntries(descriptors, context, states) {
       );
     } else {
       entry.value = createRawFunction(
-        (input) => fold(callRun)(input),
+        (input, ctx) => fold(callRun)(input, ctx),
         {
           sdk,
           name: descriptor.name,
@@ -2134,11 +2237,15 @@ function buildMethodEntries(descriptors, context, states) {
         });
         return packed;
       };
+      const internalValue = (...args) => canonicalValue(pack(args), INTERNAL_CALL);
       entry.value = (...args) => canonicalValue(pack(args));
-      entry.internalValue = (...args) => canonicalValue(pack(args), INTERNAL_CALL);
+      entry.internalValue = internalValue;
+      entry.bindInternal = (ctx) => ctx ? (...args) => canonicalValue(pack(args), childCallContext(ctx)) : internalValue;
       entry.positional = names;
     } else {
-      entry.internalValue = (input) => canonicalValue(input, INTERNAL_CALL);
+      const internalValue = (input) => canonicalValue(input, INTERNAL_CALL);
+      entry.internalValue = internalValue;
+      entry.bindInternal = (ctx) => ctx ? (input) => canonicalValue(input, childCallContext(ctx)) : internalValue;
     }
     plugins[id] = entry;
   }
@@ -2378,7 +2485,7 @@ function createSdk(root, options) {
       pluginSurface = {};
       bindValue(pluginSurface, plugin.name, plugins2[plugin.id]);
     }
-    for (const key2 of Object.keys(legacyExports)) context.surface[key2] = key2;
+    for (const key of Object.keys(legacyExports)) context.surface[key] = key;
     if (plugin.pluginType === "aggregate") {
       recordExportSurface(context, plugin.exports);
     } else {
@@ -2509,6 +2616,7 @@ function valueTypeOf(inner) {
   if (inner instanceof z.ZodEnum) return "string";
   if (inner instanceof z.ZodArray) return "array";
   if (inner instanceof z.ZodObject) return "object";
+  if (inner instanceof z.ZodRecord) return "object";
   return void 0;
 }
 function staticChoicesOf(inner) {
@@ -2519,7 +2627,8 @@ function staticChoicesOf(inner) {
   return void 0;
 }
 function objectShape(schema) {
-  const { inner } = schema ? unwrap(schema) : { inner: void 0 };
+  const canonical = canonicalInputSchema(schema);
+  const { inner } = canonical ? unwrap(canonical) : { inner: void 0 };
   if (inner instanceof z.ZodObject) {
     return inner.shape;
   }
@@ -2541,7 +2650,7 @@ function topoOrder2(specs) {
 }
 function planParameters(entry) {
   const shape = objectShape(entry.inputSchema);
-  const resolvers = entry.boundResolvers ?? {};
+  const resolvers = entry.resolvers ?? {};
   const names = shape ? [
     ...Object.keys(shape),
     ...Object.keys(resolvers).filter(
@@ -2577,24 +2686,48 @@ function getAtPath(root, path) {
   }
   return node;
 }
+function defineOwn(node, key, value) {
+  Object.defineProperty(node, key, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
 function setAtPath(root, path, value) {
   let node = root;
   for (let i = 0; i < path.length - 1; i++) {
     const seg = path[i];
-    if (node[seg] == null || typeof node[seg] !== "object") node[seg] = {};
-    node = node[seg];
+    const existing = Object.prototype.hasOwnProperty.call(node, seg) ? node[seg] : void 0;
+    if (existing != null && typeof existing === "object") {
+      node = existing;
+    } else {
+      const child = {};
+      defineOwn(node, seg, child);
+      node = child;
+    }
   }
-  node[path[path.length - 1]] = value;
+  defineOwn(node, path[path.length - 1], value);
 }
-var key = (path) => path.join(".");
+var SAFE_SEGMENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var pathToKey = (path) => {
+  let out = "";
+  for (const segment of path) {
+    if (typeof segment === "number") out += `[${segment}]`;
+    else if (SAFE_SEGMENT.test(segment))
+      out += out === "" ? segment : `.${segment}`;
+    else out += `[${JSON.stringify(segment)}]`;
+  }
+  return out;
+};
 function isSettled(state, path) {
-  return state.settled.includes(key(path));
+  return state.settled.includes(pathToKey(path));
 }
 function remember(state, k) {
   if (!state.settled.includes(k)) state.settled.push(k);
 }
 function settle(state, path) {
-  remember(state, key(path));
+  remember(state, pathToKey(path));
 }
 function clone(state) {
   return JSON.parse(JSON.stringify(state));
@@ -2609,6 +2742,28 @@ function coerce(leaf, raw) {
     if (raw === "true") return true;
     if (raw === "false") return false;
   }
+  if (leaf.valueType === "object") {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+        return raw;
+      }
+    }
+    return raw;
+  }
+  if (leaf.valueType === "array") {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("[")) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+        return raw;
+      }
+    }
+    return raw;
+  }
   return raw;
 }
 async function validationError(leaf, value, state) {
@@ -2666,27 +2821,6 @@ async function objectChildren(resolver, input) {
     return toLeaf(name, field, resolver.definitions);
   });
 }
-function arrayItem(resolver) {
-  const items = resolver.items;
-  const valueType = resolver.itemValueType;
-  if (isRef(items)) {
-    return {
-      name: "",
-      required: true,
-      resolver: resolver.definitions?.[items.ref],
-      extraInput: items.input,
-      valueType,
-      requires: []
-    };
-  }
-  return {
-    name: "",
-    required: true,
-    resolver: items,
-    valueType,
-    requires: []
-  };
-}
 function autoSettles(resolver) {
   return resolver.type === "constant" || resolver.type === "info";
 }
@@ -2706,10 +2840,28 @@ async function leafAt(ctx, path, resolved) {
     const seg = path[i];
     if (typeof seg === "number") {
       if (leaf?.resolver?.type !== "array") return void 0;
-      leaf = arrayItem(leaf.resolver);
+      leaf = boundLeaf(
+        "",
+        leaf.resolver.items,
+        leaf.resolver.definitions,
+        leaf.resolver.itemValueType
+      );
     } else {
-      leaf = children.find((c) => c.name === seg);
-      if (!leaf) return void 0;
+      const parent = leaf;
+      const found = children.find((c) => c.name === seg);
+      if (found) {
+        leaf = found;
+      } else if (parent?.resolver?.type === "object" && parent.resolver.additionalKeys) {
+        const ak = parent.resolver.additionalKeys;
+        leaf = boundLeaf(
+          String(seg),
+          ak.values,
+          parent.resolver.definitions,
+          ak.valueValueType
+        );
+      } else {
+        return void 0;
+      }
     }
     if (i < path.length - 1 && typeof path[i + 1] === "string") {
       if (leaf?.resolver?.type !== "object") return void 0;
@@ -2721,16 +2873,81 @@ async function leafAt(ctx, path, resolved) {
   }
   return leaf;
 }
+function boundLeaf(name, resolverOrRef, definitions, valueType) {
+  if (isRef(resolverOrRef)) {
+    return {
+      name,
+      required: true,
+      resolver: definitions?.[resolverOrRef.ref],
+      extraInput: resolverOrRef.input,
+      valueType,
+      requires: []
+    };
+  }
+  return {
+    name,
+    required: true,
+    resolver: resolverOrRef,
+    valueType,
+    requires: []
+  };
+}
+async function recordInfoAt(ctx, path, resolved) {
+  const leaf = await leafAt(ctx, path, resolved);
+  const resolver = leaf?.resolver;
+  if (resolver?.type !== "object" || !resolver.additionalKeys) {
+    throw new Error(
+      `expected an object resolver with additionalKeys at "${pathToKey(path)}"`
+    );
+  }
+  if (resolver.getProperties) {
+    throw new Error(
+      `object resolver at "${pathToKey(path)}" cannot combine getProperties with additionalKeys`
+    );
+  }
+  const ak = resolver.additionalKeys;
+  const defs = resolver.definitions;
+  const keyLeaf = ak.keys ? boundLeaf("key", ak.keys, defs, ak.keyValueType ?? "string") : {
+    name: "key",
+    required: true,
+    resolver: { type: "static", inputType: "text" },
+    valueType: "string",
+    requires: []
+  };
+  const valueLeaf = boundLeaf("value", ak.values, defs, ak.valueValueType);
+  if (keyLeaf.resolver && keyLeaf.resolver.type !== "static") {
+    throw new Error(
+      `record key resolver at "${pathToKey(path)}" must be a static free-text prompt, not "${keyLeaf.resolver.type}"`
+    );
+  }
+  if (valueLeaf.resolver?.type === "object" || valueLeaf.resolver?.type === "array") {
+    throw new Error(
+      `record value resolver at "${pathToKey(path)}" must be a single value, not "${valueLeaf.resolver.type}"`
+    );
+  }
+  return {
+    min: ak.minEntries ?? 0,
+    max: ak.maxEntries ?? Infinity,
+    keyLeaf,
+    valueLeaf,
+    fixedKeys: Object.keys(resolver.properties ?? {})
+  };
+}
 async function arrayInfoAt(ctx, path, resolved) {
   const leaf = await leafAt(ctx, path, resolved);
   const resolver = leaf?.resolver;
   if (resolver?.type !== "array") {
-    throw new Error(`expected an array resolver at "${key(path)}"`);
+    throw new Error(`expected an array resolver at "${pathToKey(path)}"`);
   }
   return {
     min: resolver.minItems ?? 0,
     max: resolver.maxItems ?? Infinity,
-    item: { ...arrayItem(resolver), name: String(path[path.length - 1]) }
+    item: boundLeaf(
+      String(path[path.length - 1]),
+      resolver.items,
+      resolver.definitions,
+      resolver.itemValueType
+    )
   };
 }
 async function firstPage(result) {
@@ -2809,6 +3026,9 @@ var AFFORDANCE = {
   retry: { action: "retry", description: "Retry loading the options" },
   cancel: { action: "cancel", description: "Cancel resolution" }
 };
+function affordance(base, description) {
+  return { ...base, description };
+}
 function selectActions(leaf, page, multiple) {
   const searchMode = leaf.resolver?.type === "dynamic" && leaf.resolver.inputType === "search";
   if (searchMode && page.position.search === void 0 && page.items.length === 0) {
@@ -2923,7 +3143,7 @@ async function buildQuestion(leaf, path, input) {
     }
   };
 }
-function collectionQuestion(t) {
+function arrayItemsQuestion(t) {
   const actions = [AFFORDANCE.add];
   if (t.count >= t.min) actions.push(AFFORDANCE.done);
   return {
@@ -2939,22 +3159,37 @@ function collectionQuestion(t) {
     actions
   };
 }
-function objectGateQuestion(path) {
+function recordEntriesQuestion(t) {
+  const actions = [
+    affordance(AFFORDANCE.add, "Add another entry")
+  ];
+  if (t.count >= t.min) {
+    actions.push(affordance(AFFORDANCE.done, "Finish the entries"));
+  }
+  return {
+    type: "collection",
+    path: t.path,
+    message: `Add another ${t.path[t.path.length - 1]} entry? (${t.count} so far)`,
+    container: "record",
+    count: t.count,
+    min: t.min,
+    ...Number.isFinite(t.max) ? { max: t.max } : {},
+    actions
+  };
+}
+function objectOptionalQuestion(path) {
   return {
     type: "collection",
     path,
     message: `Add ${path[path.length - 1]}?`,
     container: "object",
     actions: [
-      {
-        action: "add",
-        description: "Provide values for these fields"
-      },
-      { action: "done", description: "Skip these fields" }
+      affordance(AFFORDANCE.add, "Provide values for these fields"),
+      affordance(AFFORDANCE.done, "Skip these fields")
     ]
   };
 }
-function optionalsGateQuestion(path, pending) {
+function objectOptionalPropertiesQuestion(path, pending) {
   return {
     type: "collection",
     path,
@@ -2971,8 +3206,8 @@ function optionalsGateQuestion(path, pending) {
       ...leaf.valueType ? { valueType: leaf.valueType } : {}
     })),
     actions: [
-      { action: "add", description: "Configure the optional fields" },
-      { action: "done", description: "Skip the optional fields" }
+      affordance(AFFORDANCE.add, "Configure the optional fields"),
+      affordance(AFFORDANCE.done, "Skip the optional fields")
     ]
   };
 }
@@ -2988,7 +3223,8 @@ function finalize(ctx, resolved) {
   }));
   return { status: "invalid", issues };
 }
-var optionalsMarker = (path) => `${key(path)}?optionals`;
+var optionalsMarker = (path) => `${pathToKey(path)}?optionals`;
+var UNSAFE_RECORD_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 async function findInArray(ctx, state, path) {
   if (isSettled(state, path)) return null;
   if (getAtPath(state.resolved, path) == null)
@@ -3009,7 +3245,28 @@ async function findInArray(ctx, state, path) {
     }
   }
   if (len < min) return descendItem(ctx, state, path, len, item);
-  if (len < max) return { kind: "array", path, count: len, min, max };
+  if (len < max) return { type: "array_items", path, count: len, min, max };
+  settle(state, path);
+  return null;
+}
+async function findInRecord(ctx, state, path) {
+  if (isSettled(state, path)) return null;
+  if (getAtPath(state.resolved, path) == null)
+    setAtPath(state.resolved, path, {});
+  if (!state.interactive) {
+    settle(state, path);
+    return null;
+  }
+  const { min, max, keyLeaf, fixedKeys } = await recordInfoAt(
+    ctx,
+    path,
+    state.resolved
+  );
+  const container = getAtPath(state.resolved, path);
+  const fixed = new Set(fixedKeys);
+  const count = Object.keys(container).filter((k) => !fixed.has(k)).length;
+  if (count < min) return { type: "record_key", path, leaf: keyLeaf };
+  if (count < max) return { type: "record_entries", path, count, min, max };
   settle(state, path);
   return null;
 }
@@ -3027,10 +3284,10 @@ function seedItemSlot(state, itemPath, item) {
 }
 async function descendItem(ctx, state, arrayPath, index, item) {
   const itemPath = [...arrayPath, index];
-  const kind = seedItemSlot(state, itemPath, item);
-  if (kind === "object") return findNext(ctx, state, itemPath);
-  if (kind === "array") return findInArray(ctx, state, itemPath);
-  return { kind: "leaf", path: itemPath, leaf: item };
+  const slotType = seedItemSlot(state, itemPath, item);
+  if (slotType === "object") return findNext(ctx, state, itemPath);
+  if (slotType === "array") return findInArray(ctx, state, itemPath);
+  return { type: "leaf", path: itemPath, leaf: item };
 }
 async function findNext(ctx, state, path = []) {
   const container = getAtPath(state.resolved, path) ?? {};
@@ -3055,7 +3312,7 @@ async function findNext(ctx, state, path = []) {
       const pending = ordered.filter(
         (c) => !c.required && asksUser(c) && isPendingChild(c)
       );
-      return { kind: "optionals", path, pending };
+      return { type: "object_optional_properties", path, pending };
     }
     if (leaf.resolver?.type === "object") {
       if (isSettled(state, childPath)) continue;
@@ -3065,7 +3322,7 @@ async function findNext(ctx, state, path = []) {
             settle(state, childPath);
             continue;
           }
-          return { kind: "object", path: childPath, leaf };
+          return { type: "object_optional", path: childPath, leaf };
         }
         setAtPath(state.resolved, childPath, {});
       }
@@ -3097,13 +3354,21 @@ async function findNext(ctx, state, path = []) {
     }
     if (container[leaf.name] !== void 0 || isSettled(state, childPath))
       continue;
-    return { kind: "leaf", path: childPath, leaf };
+    return { type: "leaf", path: childPath, leaf };
+  }
+  if (inObject && !isSettled(state, path)) {
+    const self = await leafAt(ctx, path, state.resolved);
+    if (self?.resolver?.type === "object" && self.resolver.additionalKeys) {
+      const rec = await findInRecord(ctx, state, path);
+      if (rec) return rec;
+    }
   }
   return null;
 }
 async function askLeaf(state, path, leaf, opts = {}) {
   state.current = path;
-  delete state.gate;
+  if (opts.gate) state.gate = opts.gate;
+  else delete state.gate;
   try {
     const { question, pagination } = await buildQuestion(
       leaf,
@@ -3124,6 +3389,28 @@ async function askLeaf(state, path, leaf, opts = {}) {
     return failedResult(state, leaf.name, error);
   }
 }
+async function askRecordKey(state, path, keyLeaf, opts = {}) {
+  return askLeaf(state, path, keyLeaf, { gate: "record_key", ...opts });
+}
+async function autoResolveLeaf(state, path, leaf) {
+  const resolver = leaf.resolver;
+  if (resolver && autoSettles(resolver)) {
+    if (resolver.type === "constant")
+      setAtPath(state.resolved, path, resolver.value);
+    settle(state, path);
+    return true;
+  }
+  const auto = resolver?.type === "dynamic" ? await resolver.tryResolveWithoutPrompt?.({
+    input: mergeInput(state.resolved, leaf.extraInput)
+  }) : void 0;
+  if (auto) {
+    if (auto.resolvedValue !== void 0)
+      setAtPath(state.resolved, path, auto.resolvedValue);
+    settle(state, path);
+    return true;
+  }
+  return false;
+}
 async function advance(ctx, state) {
   for (; ; ) {
     const target = await findNext(ctx, state);
@@ -3133,54 +3420,56 @@ async function advance(ctx, state) {
       delete state.pagination;
       return { state, result: finalize(ctx, state.resolved) };
     }
-    if (target.kind === "array") {
+    if (target.type === "array_items") {
       state.current = target.path;
-      state.gate = "array";
+      state.gate = "array_items";
       delete state.pagination;
       return {
         state,
-        result: { status: "ask", question: collectionQuestion(target) }
+        result: { status: "ask", question: arrayItemsQuestion(target) }
       };
     }
-    if (target.kind === "object") {
+    if (target.type === "object_optional") {
       state.current = target.path;
-      state.gate = "entry";
+      state.gate = "object_optional";
       delete state.pagination;
       return {
         state,
-        result: { status: "ask", question: objectGateQuestion(target.path) }
+        result: {
+          status: "ask",
+          question: objectOptionalQuestion(target.path)
+        }
       };
     }
-    if (target.kind === "optionals") {
+    if (target.type === "object_optional_properties") {
       state.current = target.path;
-      state.gate = "optionals";
+      state.gate = "object_optional_properties";
       delete state.pagination;
       return {
         state,
         result: {
           status: "ask",
-          question: optionalsGateQuestion(target.path, target.pending)
+          question: objectOptionalPropertiesQuestion(
+            target.path,
+            target.pending
+          )
         }
       };
     }
-    const { path, leaf } = target;
-    const resolver = leaf.resolver;
-    if (resolver && autoSettles(resolver)) {
-      if (resolver.type === "constant") {
-        setAtPath(state.resolved, path, resolver.value);
-      }
-      settle(state, path);
-      continue;
+    if (target.type === "record_entries") {
+      state.current = target.path;
+      state.gate = "record_entries";
+      delete state.pagination;
+      return {
+        state,
+        result: { status: "ask", question: recordEntriesQuestion(target) }
+      };
     }
-    const auto = resolver?.type === "dynamic" ? await resolver.tryResolveWithoutPrompt?.({
-      input: mergeInput(state.resolved, leaf.extraInput)
-    }) : void 0;
-    if (auto) {
-      if (auto.resolvedValue !== void 0)
-        setAtPath(state.resolved, path, auto.resolvedValue);
-      settle(state, path);
-      continue;
+    if (target.type === "record_key") {
+      return askRecordKey(state, target.path, target.leaf);
     }
+    const { path, leaf } = target;
+    if (await autoResolveLeaf(state, path, leaf)) continue;
     if (!state.interactive) {
       if (!leaf.required) {
         settle(state, path);
@@ -3213,10 +3502,18 @@ async function step(ctx, prior, action) {
     delete state.pagination;
     return { state, result: { status: "cancelled" } };
   }
+  if (state.gate === "record_key") {
+    return stepRecordKey(ctx, state, action);
+  }
   const path = state.current;
   if (!path) throw new Error("step called with no outstanding question");
   const leaf = await leafAt(ctx, path, state.resolved);
-  if (leaf && (action.type === "search" || action.type === "next_page" || action.type === "previous_page" || action.type === "retry")) {
+  if (!leaf) {
+    throw new Error(
+      `no resolver for the outstanding question at "${pathToKey(path)}"`
+    );
+  }
+  if (action.type === "search" || action.type === "next_page" || action.type === "previous_page" || action.type === "retry") {
     return refine(ctx, state, leaf, path, action);
   }
   if (action.type === "add" || action.type === "done") {
@@ -3233,19 +3530,26 @@ async function step(ctx, prior, action) {
       settle(state, path);
       return advance(ctx, state);
     }
-    if (gate === "entry") {
+    if (gate === "object_optional") {
       setAtPath(state.resolved, path, {});
       return advance(ctx, state);
     }
-    if (gate === "optionals") {
+    if (gate === "object_optional_properties") {
       remember(state, optionalsMarker(path));
       return advance(ctx, state);
     }
+    if (gate === "record_entries") {
+      const { keyLeaf } = await recordInfoAt(ctx, path, state.resolved);
+      return askRecordKey(state, path, keyLeaf);
+    }
     const items = getAtPath(state.resolved, path) ?? [];
     const { item } = await arrayInfoAt(ctx, path, state.resolved);
     const itemPath = [...path, items.length];
-    if (seedItemSlot(state, itemPath, item) === "leaf")
+    if (seedItemSlot(state, itemPath, item) === "leaf") {
+      if (await autoResolveLeaf(state, itemPath, item))
+        return advance(ctx, state);
       return askLeaf(state, itemPath, item);
+    }
     return advance(ctx, state);
   }
   if (state.gate) {
@@ -3256,81 +3560,37 @@ async function step(ctx, prior, action) {
   switch (action.type) {
     case "choose":
     case "custom": {
-      if (leaf) {
-        let error;
-        try {
-          error = await validationError(leaf, action.value, state);
-        } catch (thrown) {
-          return failedResult(state, leaf.name, thrown);
-        }
-        if (error) {
-          if (state.pagination && leaf.resolver?.type === "dynamic") {
-            try {
-              const context = await resolveContext(leaf, state.resolved);
-              const page = await fetchListing(
-                leaf,
-                state.resolved,
-                state.pagination.position,
-                context
-              );
-              state.pagination = toPagination(page);
-              return {
-                state,
-                result: {
-                  status: "ask",
-                  question: selectQuestion(
-                    leaf,
-                    path,
-                    state.resolved,
-                    page,
-                    context
-                  ),
-                  error
-                }
-              };
-            } catch (fetchError) {
-              state.pagination = failedPagination(
-                state.pagination,
-                state.pagination.position
-              );
-              return failedResult(state, leaf.name, fetchError);
-            }
-          }
-          return askLeaf(state, path, leaf, { error });
+      let error;
+      try {
+        error = await validationError(leaf, action.value, state);
+      } catch (thrown) {
+        return failedResult(state, leaf.name, thrown);
+      }
+      if (error) {
+        if (state.pagination && leaf.resolver?.type === "dynamic") {
+          return renderPageAt(state, leaf, path, state.pagination.position, {
+            error
+          });
         }
+        return askLeaf(state, path, leaf, { error });
       }
-      setAtPath(
-        state.resolved,
-        path,
-        leaf ? coerce(leaf, action.value) : action.value
-      );
+      setAtPath(state.resolved, path, coerce(leaf, action.value));
       break;
     }
     case "skip":
       settle(state, path);
       break;
     default:
-      throw new Error(`action "${action.type}" is not supported here`);
+      throw new Error(
+        `action "${action.type}" is not supported here`
+      );
   }
   delete state.current;
   delete state.pagination;
   return advance(ctx, state);
 }
-async function refine(ctx, state, leaf, path, action) {
-  const position = positionAfter(state.pagination, action);
+async function renderPageAt(state, leaf, path, position, opts = {}) {
   try {
-    if (action.type === "search") {
-      const exact = leaf.resolver?.type === "dynamic" ? await leaf.resolver.tryResolveFromSearch?.({
-        input: mergeInput(state.resolved, leaf.extraInput),
-        search: action.term
-      }) : void 0;
-      if (exact) {
-        setAtPath(state.resolved, path, coerce(leaf, exact.resolvedValue));
-        delete state.current;
-        delete state.pagination;
-        return advance(ctx, state);
-      }
-    }
     const context = await resolveContext(leaf, state.resolved);
     const page = await fetchListing(leaf, state.resolved, position, context);
     state.pagination = toPagination(page);
@@ -3338,7 +3598,8 @@ async function refine(ctx, state, leaf, path, action) {
       state,
       result: {
         status: "ask",
-        question: selectQuestion(leaf, path, state.resolved, page, context)
+        question: selectQuestion(leaf, path, state.resolved, page, context),
+        ...opts.error ? { error: opts.error } : {}
       }
     };
   } catch (error) {
@@ -3346,6 +3607,65 @@ async function refine(ctx, state, leaf, path, action) {
     return failedResult(state, leaf.name, error);
   }
 }
+async function refine(ctx, state, leaf, path, action) {
+  const position = positionAfter(state.pagination, action);
+  if (action.type === "search") {
+    try {
+      const exact = leaf.resolver?.type === "dynamic" ? await leaf.resolver.tryResolveFromSearch?.({
+        input: mergeInput(state.resolved, leaf.extraInput),
+        search: action.term
+      }) : void 0;
+      if (exact) {
+        setAtPath(state.resolved, path, coerce(leaf, exact.resolvedValue));
+        delete state.current;
+        delete state.pagination;
+        return advance(ctx, state);
+      }
+    } catch (error) {
+      state.pagination = failedPagination(state.pagination, position);
+      return failedResult(state, leaf.name, error);
+    }
+  }
+  return renderPageAt(state, leaf, path, position);
+}
+async function stepRecordKey(ctx, state, action) {
+  const path = state.current;
+  if (!path)
+    throw new Error("record key step called with no outstanding question");
+  const { keyLeaf, valueLeaf } = await recordInfoAt(ctx, path, state.resolved);
+  if (action.type === "skip") {
+    delete state.gate;
+    delete state.current;
+    delete state.pagination;
+    return advance(ctx, state);
+  }
+  if (action.type !== "custom" && action.type !== "choose") {
+    throw new Error(
+      `action "${action.type}" is not supported while entering a record key`
+    );
+  }
+  const raw = Array.isArray(action.value) ? action.value[0] : action.value;
+  const entryKey = String(coerce(keyLeaf, raw));
+  if (entryKey.trim() === "") {
+    return askRecordKey(state, path, keyLeaf, { error: "A key is required." });
+  }
+  if (UNSAFE_RECORD_KEYS.has(entryKey)) {
+    return askRecordKey(state, path, keyLeaf, {
+      error: `"${entryKey}" is not an allowed key.`
+    });
+  }
+  const container = getAtPath(state.resolved, path);
+  if (Object.prototype.hasOwnProperty.call(container, entryKey)) {
+    return askRecordKey(state, path, keyLeaf, {
+      error: `"${entryKey}" is already set.`
+    });
+  }
+  const valuePath = [...path, entryKey];
+  if (await autoResolveLeaf(state, valuePath, valueLeaf)) {
+    return advance(ctx, state);
+  }
+  return askLeaf(state, valuePath, valueLeaf);
+}
 function failedPagination(pagination, retryPosition) {
   return {
     position: pagination?.position ?? firstPagePosition(),
@@ -3399,7 +3719,7 @@ function projectSummary(entry) {
   };
 }
 function projectMethod(entry) {
-  const inputProperties = toJsonSchema(entry.inputSchema)?.properties;
+  const inputProperties = toJsonSchema(canonicalInputSchema(entry.inputSchema))?.properties;
   const parameters = {};
   for (const spec of planParameters(entry).parameters) {
     const dynamic = spec.resolver?.type === "dynamic" ? spec.resolver : void 0;
@@ -3432,7 +3752,12 @@ function createController(sdk) {
     const entry = entryFor(method);
     return {
       method,
-      schema: entry.inputSchema,
+      // A method that owns its input validation (`skipInputValidation`, e.g.
+      // fetch) must not be re-validated by the controller's final `safeParse`;
+      // drop the schema so `finalize` returns the resolved input untouched.
+      // Planning still reads `entry.inputSchema` directly, so parameters are
+      // unaffected.
+      schema: entry.skipInputValidation ? void 0 : entry.inputSchema,
       parameters: planParameters(entry).parameters
     };
   }
@@ -3495,27 +3820,6 @@ function createCorePlugin(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 (schema instanceof z.ZodOptional) {
-    return isPositional(schema._zod.def.innerType);
-  }
-  if (schema instanceof z.ZodDefault) {
-    return isPositional(schema._zod.def.innerType);
-  }
-  return false;
-}
 
 // src/constants.ts
 var ZAPIER_BASE_URL = globalThis.process?.env?.ZAPIER_BASE_URL || "https://zapier.com";
@@ -4070,8 +4374,8 @@ function censorHeaders(headers) {
   if (!headers) return headers;
   const headersObj = new Headers(headers);
   const authKeys = ["authorization", "x-api-key"];
-  for (const [key2, value] of headersObj.entries()) {
-    if (authKeys.some((authKey) => key2.toLowerCase() === authKey)) {
+  for (const [key, value] of headersObj.entries()) {
+    if (authKeys.some((authKey) => key.toLowerCase() === authKey)) {
       const spaceIndex = value.indexOf(" ");
       if (spaceIndex > 0 && spaceIndex < value.length - 1) {
         const prefix = value.substring(0, spaceIndex + 1);
@@ -4079,19 +4383,19 @@ function censorHeaders(headers) {
         if (token.length > 12) {
           const start2 = token.substring(0, 4);
           const end = token.substring(token.length - 4);
-          headersObj.set(key2, `${prefix}${start2}...${end}`);
+          headersObj.set(key, `${prefix}${start2}...${end}`);
         } else {
           const firstChar = token.charAt(0);
-          headersObj.set(key2, `${prefix}${firstChar}...`);
+          headersObj.set(key, `${prefix}${firstChar}...`);
         }
       } else {
         if (value.length > 12) {
           const start2 = value.substring(0, 4);
           const end = value.substring(value.length - 4);
-          headersObj.set(key2, `${start2}...${end}`);
+          headersObj.set(key, `${start2}...${end}`);
         } else {
           const firstChar = value.charAt(0);
-          headersObj.set(key2, `${firstChar}...`);
+          headersObj.set(key, `${firstChar}...`);
         }
       }
     }
@@ -4742,21 +5046,21 @@ function getClientIdFromCredentials(credentials) {
 function createMemoryCache() {
   const store = /* @__PURE__ */ new Map();
   return {
-    async get(key2) {
-      const entry = store.get(key2);
+    async get(key) {
+      const entry = store.get(key);
       if (!entry) return void 0;
       if (entry.expiresAt !== void 0 && entry.expiresAt <= Date.now()) {
-        store.delete(key2);
+        store.delete(key);
         return void 0;
       }
       return { value: entry.value, expiresAt: entry.expiresAt };
     },
-    async set(key2, value, options) {
+    async set(key, value, options) {
       const expiresAt = options?.ttl ? Date.now() + options.ttl * 1e3 : void 0;
-      store.set(key2, { value, expiresAt });
+      store.set(key, { value, expiresAt });
     },
-    async delete(key2) {
-      store.delete(key2);
+    async delete(key) {
+      store.delete(key);
     }
   };
 }
@@ -5419,7 +5723,7 @@ function parseDeprecationDate(value) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.85.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.86.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -5677,11 +5981,11 @@ var ZapierApiClient = class {
       );
       const inputHeaders = new Headers(init?.headers ?? {});
       const mergedHeaders = new Headers();
-      builtHeaders.forEach((value, key2) => {
-        mergedHeaders.set(key2, value);
+      builtHeaders.forEach((value, key) => {
+        mergedHeaders.set(key, value);
       });
-      inputHeaders.forEach((value, key2) => {
-        mergedHeaders.set(key2, value);
+      inputHeaders.forEach((value, key) => {
+        mergedHeaders.set(key, value);
       });
       this.applyTelemetryHeaders(mergedHeaders);
       let retries = 0;
@@ -6206,8 +6510,8 @@ var ZapierApiClient = class {
       canSendDeprecationMessaging
     } = this.applyPathConfiguration(path);
     if (searchParams) {
-      Object.entries(searchParams).forEach(([key2, value]) => {
-        url.searchParams.set(key2, value);
+      Object.entries(searchParams).forEach(([key, value]) => {
+        url.searchParams.set(key, value);
       });
     }
     return {
@@ -7106,13 +7410,13 @@ function parseManifestSection({
     return void 0;
   }
   const kept = {};
-  for (const [key2, value] of Object.entries(raw)) {
+  for (const [key, value] of Object.entries(raw)) {
     const result = schema.safeParse(value);
     if (result.success) {
-      kept[key2] = result.data;
+      kept[key] = result.data;
     } else {
       console.warn(
-        `\u26A0\uFE0F Dropping invalid "${section}" entry "${key2}" in ${source}: ${result.error}`
+        `\u26A0\uFE0F Dropping invalid "${section}" entry "${key}" in ${source}: ${result.error}`
       );
     }
   }
@@ -7261,9 +7565,9 @@ function findManifestEntry({
       return [slug, manifest.apps[slug]];
     }
   }
-  for (const [key2, entry] of Object.entries(manifest.apps)) {
+  for (const [key, entry] of Object.entries(manifest.apps)) {
     if (entry.implementationName === appKeyWithoutVersion) {
-      return [key2, entry];
+      return [key, entry];
     }
   }
   return null;
@@ -7517,8 +7821,8 @@ function normalizeHeaders(optionsHeaders) {
     return headers;
   }
   const headerEntries = optionsHeaders instanceof Headers ? Array.from(optionsHeaders.entries()) : Array.isArray(optionsHeaders) ? optionsHeaders : Object.entries(optionsHeaders);
-  for (const [key2, value] of headerEntries) {
-    headers[key2] = value;
+  for (const [key, value] of headerEntries) {
+    headers[key] = value;
   }
   return headers;
 }
@@ -7589,14 +7893,9 @@ var fetchPlugin = defineMethod({
   // of order.
   categories: [{ key: "http", title: "HTTP Request" }],
   returnType: "Response",
-  // The controller / MCP project fetch's parameters from `inputSchema` +
-  // `positional`. The CLI command layer instead flattens `init`'s fields into
-  // individual flags (--method, --connection, ...) from `inputParameters`; it is
-  // the only surface that reads this. Both describe the same (url, init) shape.
-  inputParameters: [
-    { name: "url", schema: FetchUrlSchema },
-    { name: "init", schema: FetchInitSchema }
-  ],
+  // The CLI, controller, and MCP all derive fetch's `(url, init)` shape from
+  // `inputSchema` + `positional`; the CLI flattens `init`'s fields into
+  // individual flags (--method, --connection, ...) off that same schema.
   // Build the validator once, binding it to the head's `adaptError` so failures
   // surface as `ZapierValidationError` rather than the neutral kitcore fallback.
   setup: ({ imports }) => {
@@ -7735,9 +8034,9 @@ var RunActionInputSchema = z.union([RunActionSchema, RunActionSchemaDeprecated])
 var ActionResultItemSchema = z.unknown().describe("Action execution result");
 
 // src/formatters/actionResult.ts
-function getStringProperty(obj, key2) {
-  if (typeof obj === "object" && obj !== null && key2 in obj) {
-    const value = obj[key2];
+function getStringProperty(obj, key) {
+  if (typeof obj === "object" && obj !== null && key in obj) {
+    const value = obj[key];
     return typeof value === "string" ? value : void 0;
   }
   return void 0;
@@ -8223,21 +8522,21 @@ var actionKeyResolver = defineResolver({
 });
 
 // src/plugins/capabilities/index.ts
-function toDescription(key2) {
-  const words = key2.replace(/^can/, "").replace(/([A-Z])/g, " $1").trim().toLowerCase();
+function toDescription(key) {
+  const words = key.replace(/^can/, "").replace(/([A-Z])/g, " $1").trim().toLowerCase();
   return `To ${words}`;
 }
-function toEnvVar(key2) {
-  return "ZAPIER_" + key2.replace(/([A-Z])/g, "_$1").toUpperCase();
+function toEnvVar(key) {
+  return "ZAPIER_" + key.replace(/([A-Z])/g, "_$1").toUpperCase();
 }
-function toCliFlag(key2) {
-  return "--" + key2.replace(/([A-Z])/g, "-$1").toLowerCase();
+function toCliFlag(key) {
+  return "--" + key.replace(/([A-Z])/g, "-$1").toLowerCase();
 }
-function buildCapabilityMessage(key2) {
+function buildCapabilityMessage(key) {
   return [
-    `${toDescription(key2)}, use ${toCliFlag(key2)} in the CLI,`,
-    `set ${key2}: true in SDK options or .zapierrc,`,
-    `or set ${toEnvVar(key2)}=true.`
+    `${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 = [
@@ -8245,8 +8544,8 @@ var GATED_FLAGS = [
   "canIncludeSharedTables",
   "canDeleteTables"
 ];
-function isEnabledByEnv(key2) {
-  const value = globalThis.process?.env?.[toEnvVar(key2)];
+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;
@@ -8273,17 +8572,17 @@ var capabilitiesPlugin = defineProperty({
       return cached;
     }
     return {
-      checkCapability: async (key2) => {
+      checkCapability: async (key) => {
         const flags = await resolveFlags();
-        if (flags[key2]) return;
+        if (flags[key]) return;
         throw new ZapierConfigurationError(
-          buildCapabilityMessage(key2) + " (If you are an AI agent, you MUST NOT retry. Ask the user if they want to enable this.)",
-          { configType: key2 }
+          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 (key2) => {
+      hasCapability: async (key) => {
         const flags = await resolveFlags();
-        return flags[key2];
+        return flags[key];
       }
     };
   },
@@ -8780,7 +9079,7 @@ function formatRecordError(fieldId, err) {
 function formatResponseError(err) {
   const message = err.human_title || err.title || "Unknown error";
   if (err.meta && Object.keys(err.meta).length > 0) {
-    const metaParts = Object.entries(err.meta).map(([key2, val]) => `${key2}: ${JSON.stringify(val)}`).join(", ");
+    const metaParts = Object.entries(err.meta).map(([key, val]) => `${key}: ${JSON.stringify(val)}`).join(", ");
     return `${message} (${metaParts})`;
   }
   return message;
@@ -8815,8 +9114,8 @@ var TrashSchema = z.enum(["exclude", "include", "only"]).optional().describe(
   'Control soft-deleted item visibility. "exclude" (default) returns active items only, "include" returns both active and soft-deleted, "only" returns soft-deleted items only.'
 );
 var FIELD_ID_PATTERN = /^f\d+$/;
-function isFieldId(key2) {
-  return FIELD_ID_PATTERN.test(key2);
+function isFieldId(key) {
+  return FIELD_ID_PATTERN.test(key);
 }
 var NESTED_COMPONENTS = {
   labeled_string: /* @__PURE__ */ new Set(["value"]),
@@ -8854,7 +9153,7 @@ async function resolveFieldKeys({
   fieldKeys
 }) {
   const allAreIds = fieldKeys.every(
-    (key2) => typeof key2 === "number" || /^(f?\d+)$/.test(key2)
+    (key) => typeof key === "number" || /^(f?\d+)$/.test(key)
   );
   if (allAreIds) {
     return fieldKeys.map(toNumericFieldId);
@@ -8863,13 +9162,13 @@ async function resolveFieldKeys({
   if (!mapping) {
     return fieldKeys.map(toNumericFieldId);
   }
-  return fieldKeys.map((key2) => {
-    if (typeof key2 === "number") return key2;
-    if (FIELD_ID_PATTERN.test(key2)) return toNumericFieldId(key2);
-    const id = mapping.nameToId.get(key2);
+  return fieldKeys.map((key) => {
+    if (typeof key === "number") return key;
+    if (FIELD_ID_PATTERN.test(key)) return toNumericFieldId(key);
+    const id = mapping.nameToId.get(key);
     if (!id) {
       throw new ZapierValidationError(
-        `Unknown field name: "${key2}". Use a valid field name or ID.`
+        `Unknown field name: "${key}". Use a valid field name or ID.`
       );
     }
     return toNumericFieldId(id);
@@ -8885,13 +9184,13 @@ async function createFieldKeyTranslator({
     translateInput(data) {
       if (!mapping) return data;
       const result = {};
-      for (const [key2, value] of Object.entries(data)) {
-        if (FIELD_ID_PATTERN.test(key2) && mapping.idToName.has(key2)) {
-          result[key2] = value;
-        } else if (mapping.nameToId.has(key2)) {
-          result[mapping.nameToId.get(key2)] = value;
+      for (const [key, value] of Object.entries(data)) {
+        if (FIELD_ID_PATTERN.test(key) && mapping.idToName.has(key)) {
+          result[key] = value;
+        } else if (mapping.nameToId.has(key)) {
+          result[mapping.nameToId.get(key)] = value;
         } else {
-          result[key2] = value;
+          result[key] = value;
         }
       }
       return result;
@@ -8899,29 +9198,29 @@ async function createFieldKeyTranslator({
     translateOutput(data) {
       if (!mapping) return data;
       const result = {};
-      for (const [key2, value] of Object.entries(data)) {
-        if (mapping.idToName.has(key2)) {
-          result[mapping.idToName.get(key2)] = value;
+      for (const [key, value] of Object.entries(data)) {
+        if (mapping.idToName.has(key)) {
+          result[mapping.idToName.get(key)] = value;
         } else {
-          result[key2] = value;
+          result[key] = value;
         }
       }
       return result;
     },
-    translateFieldKey(key2) {
-      if (!mapping) return key2;
-      if (FIELD_ID_PATTERN.test(key2) && mapping.idToName.has(key2)) {
-        const fieldType = mapping.idToType.get(key2);
+    translateFieldKey(key) {
+      if (!mapping) return key;
+      if (FIELD_ID_PATTERN.test(key) && mapping.idToName.has(key)) {
+        const fieldType = mapping.idToType.get(key);
         if (fieldType) {
           const components = NESTED_COMPONENTS[fieldType];
           if (components?.size === 1) {
-            return `${key2}__${[...components][0]}`;
+            return `${key}__${[...components][0]}`;
           }
         }
-        return key2;
+        return key;
       }
-      if (mapping.nameToId.has(key2)) {
-        const fieldId = mapping.nameToId.get(key2);
+      if (mapping.nameToId.has(key)) {
+        const fieldId = mapping.nameToId.get(key);
         const fieldType = mapping.idToType.get(fieldId);
         if (fieldType) {
           const components = NESTED_COMPONENTS[fieldType];
@@ -8931,10 +9230,10 @@ async function createFieldKeyTranslator({
         }
         return fieldId;
       }
-      const sepIndex = key2.lastIndexOf("__");
+      const sepIndex = key.lastIndexOf("__");
       if (sepIndex > 0) {
-        const prefix = key2.slice(0, sepIndex);
-        const component = key2.slice(sepIndex + 2);
+        const prefix = key.slice(0, sepIndex);
+        const component = key.slice(sepIndex + 2);
         let fieldId;
         if (FIELD_ID_PATTERN.test(prefix) && mapping.idToName.has(prefix)) {
           fieldId = prefix;
@@ -8948,7 +9247,7 @@ async function createFieldKeyTranslator({
           }
         }
       }
-      return key2;
+      return key;
     }
   };
 }
@@ -9544,13 +9843,13 @@ var runActionPlugin = defineMethod({
       let oldestKey;
       let oldestExpiry = Infinity;
       let evictedAny = false;
-      for (const [key2, entry] of cache) {
+      for (const [key, entry] of cache) {
         if (now >= entry.expiresAt) {
-          cache.delete(key2);
+          cache.delete(key);
           evictedAny = true;
         } else if (entry.expiresAt < oldestExpiry) {
           oldestExpiry = entry.expiresAt;
-          oldestKey = key2;
+          oldestKey = key;
         }
       }
       if (!evictedAny && oldestKey) cache.delete(oldestKey);
@@ -9908,7 +10207,7 @@ var listAppsPlugin = defineMethod({
         locator
       ];
     }
-    const duplicatedLookupAppKeys = Object.keys(implementationNameToLocator).filter((key2) => implementationNameToLocator[key2].length > 1).map((key2) => implementationNameToLocator[key2]).flat().map((locator) => locator.lookupAppKey);
+    const duplicatedLookupAppKeys = Object.keys(implementationNameToLocator).filter((key) => implementationNameToLocator[key].length > 1).map((key) => implementationNameToLocator[key]).flat().map((locator) => locator.lookupAppKey);
     if (duplicatedLookupAppKeys.length > 0) {
       throw new Error(
         `Duplicate lookup app keys found: ${duplicatedLookupAppKeys.join(", ")}`
@@ -10073,8 +10372,8 @@ function formatRootField(item) {
 }
 var rootFieldItemFormatter = defineFormatter({
   format: ({ item }) => {
-    const { key: key2, ...rest } = formatRootField(item);
-    return { ...rest, hint: key2 };
+    const { key, ...rest } = formatRootField(item);
+    return { ...rest, hint: key };
   }
 });
 
@@ -11734,7 +12033,7 @@ var createTriggerInboxPlugin = defineMethod({
       inputs = {},
       notificationUrl
     } = input;
-    const key2 = input.key ?? input.name;
+    const key = input.key ?? input.name;
     const resolvedConnectionId = await resolveConnectionId({
       connection,
       resolveConnection
@@ -11754,8 +12053,8 @@ var createTriggerInboxPlugin = defineMethod({
         connection_id: resolvedConnectionId ?? null
       }
     };
-    if (key2 !== void 0) {
-      requestBody.key = key2;
+    if (key !== void 0) {
+      requestBody.key = key;
     }
     if (notificationUrl !== void 0) {
       requestBody.notification_url = notificationUrl;
@@ -11769,7 +12068,7 @@ var createTriggerInboxPlugin = defineMethod({
           if (status === 409) {
             const detail = extractErrorDetail(data);
             return new ZapierConflictError(
-              detail ?? `An inbox with key "${key2}" already exists with a different subscription.`,
+              detail ?? `An inbox with key "${key}" already exists with a different subscription.`,
               { statusCode: status, resourceType: "trigger_inbox" }
             );
           }
@@ -11837,7 +12136,7 @@ var ensureTriggerInboxPlugin = defineMethod({
       inputs = {},
       notificationUrl
     } = input;
-    const key2 = "key" in input ? input.key : input.name;
+    const key = "key" in input ? input.key : input.name;
     const resolvedConnectionId = await resolveConnectionId({
       connection,
       resolveConnection
@@ -11850,7 +12149,7 @@ var ensureTriggerInboxPlugin = defineMethod({
       );
     }
     const requestBody = {
-      key: key2,
+      key,
       subscription: {
         app_key: selectedApi,
         action_key: actionKey,
@@ -11870,7 +12169,7 @@ var ensureTriggerInboxPlugin = defineMethod({
           if (status === 409) {
             const detail = extractErrorDetail(data);
             return new ZapierConflictError(
-              detail ?? `An inbox with key "${key2}" already exists with a different subscription.`,
+              detail ?? `An inbox with key "${key}" already exists with a different subscription.`,
               { statusCode: status, resourceType: "trigger_inbox" }
             );
           }
@@ -12454,9 +12753,9 @@ function createWaiter() {
     }
   };
 }
-function addToMap(m, key2, value) {
-  const existing = m.get(key2) ?? [];
-  m.set(key2, [...existing, value]);
+function addToMap(m, key, value) {
+  const existing = m.get(key) ?? [];
+  m.set(key, [...existing, value]);
 }
 async function runBatchedDrainPipeline(options) {
   const {
@@ -14153,8 +14452,8 @@ function getOsInfo() {
 function getPlatformVersions() {
   const versions = {};
   if (typeof globalThis.process?.versions === "object") {
-    for (const [key2, value] of Object.entries(globalThis.process.versions)) {
-      versions[key2] = value || null;
+    for (const [key, value] of Object.entries(globalThis.process.versions)) {
+      versions[key] = value || null;
     }
   }
   return versions;
@@ -14408,9 +14707,9 @@ async function emitWithTimeout(transport, subject, event) {
 }
 function mergeUserContext(event, userContext) {
   const merged = { ...event };
-  for (const [key2, value] of Object.entries(userContext)) {
-    if (merged[key2] == null) {
-      merged[key2] = value;
+  for (const [key, value] of Object.entries(userContext)) {
+    if (merged[key] == null) {
+      merged[key] = value;
     }
   }
   return merged;