@zapier/zapier-sdk 0.98.0 → 0.99.0

package/dist/{chunk-XZU6XQNV.cjs → chunk-BUAAO3AY.cjs}

@@ -35,6 +35,30 @@ function canonicalInputSchema(schema) {
   }
   return schema;
 }
+function unwrapSchema(schema) {
+  let inner = schema;
+  let required = true;
+  for (; ; ) {
+    if (inner instanceof zod.z.ZodOptional || inner instanceof zod.z.ZodDefault) {
+      required = false;
+      inner = inner.unwrap();
+    } else if (inner instanceof zod.z.ZodNullable) {
+      inner = inner.unwrap();
+    } else {
+      break;
+    }
+  }
+  return { inner, required };
+}
+function objectShapeOf(schema) {
+  const canonical = canonicalInputSchema(schema);
+  if (!canonical) return void 0;
+  const { inner } = unwrapSchema(canonical);
+  if (inner instanceof zod.z.ZodObject) {
+    return inner.shape;
+  }
+  return void 0;
+}
 function withPositional(schema) {
   Object.assign(schema._zod.def, {
     positionalMeta: { positional: true }
@@ -551,6 +575,117 @@ function createValidator(schema, { adaptError } = {}) {
   };
 }
 var validateOptions = (schema, options, { adaptError } = {}) => parseOrThrow(schema, options, { adaptError });
+var CallFrameworkOptionsSchema = zod.z.object({
+  /** Page to fetch. Opaque to kitcore: the head's API defines the format. */
+  cursor: zod.z.string().optional(),
+  /** Items per page. */
+  pageSize: zod.z.number().int().min(1).optional(),
+  /** Stop after this many items, across pages. */
+  maxItems: zod.z.number().int().min(0).optional(),
+  /** Bypass output validation for this one call. */
+  skipOutputDataValidation: zod.z.boolean().optional()
+});
+var ITEM_FRAMEWORK_OPTIONS = {
+  claims: ["skipOutputDataValidation"],
+  injects: []
+};
+var LIST_FRAMEWORK_OPTIONS = {
+  claims: ["cursor", "pageSize", "maxItems", "skipOutputDataValidation"],
+  injects: ["cursor", "pageSize"]
+};
+var PAGE_FRAMEWORK_OPTIONS = {
+  claims: ["cursor", "pageSize", "maxItems"],
+  injects: ["cursor", "pageSize", "maxItems"]
+};
+var NO_FRAMEWORK_OPTIONS = {
+  claims: [],
+  injects: []
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function strictlyRefused(error, claims) {
+  const refused = /* @__PURE__ */ new Set();
+  for (const issue of error.issues) {
+    if (issue.code !== "unrecognized_keys" || issue.path.length > 0) continue;
+    for (const key of issue.keys) {
+      if (claims.includes(key)) refused.add(key);
+    }
+  }
+  return [...refused];
+}
+function withoutKeys(options, keys) {
+  const next = {};
+  for (const [key, value] of Object.entries(options)) {
+    if (!keys.includes(key)) next[key] = value;
+  }
+  return next;
+}
+function parseCallOptions(options, {
+  schema,
+  policy = NO_FRAMEWORK_OPTIONS,
+  adaptError
+} = {}) {
+  const claims = policy.claims;
+  const call = isRecord(options) ? options : void 0;
+  let framework = {};
+  if (call && claims.length > 0) {
+    const present = {};
+    for (const key of claims) {
+      if (key in call) present[key] = call[key];
+    }
+    framework = parseOrThrow2(CallFrameworkOptionsSchema, present, adaptError);
+  }
+  if (!schema) return { framework, domain: options, supplied: /* @__PURE__ */ new Set() };
+  const first = schema.safeParse(options);
+  if (first.success) {
+    return { framework, domain: first.data, supplied: /* @__PURE__ */ new Set() };
+  }
+  const refused = call ? strictlyRefused(first.error, claims) : [];
+  if (refused.length === 0) throw toCoreError(first.error, options, adaptError);
+  const retry = schema.safeParse(withoutKeys(call, refused));
+  if (!retry.success) {
+    throw toCoreError(retry.error, options, adaptError);
+  }
+  return { framework, domain: retry.data, supplied: new Set(refused) };
+}
+function mergeCallOptions({
+  framework,
+  domain
+}) {
+  const claimed = Object.entries(framework);
+  if (!isRecord(domain) || claimed.length === 0) return domain;
+  return { ...domain, ...Object.fromEntries(claimed) };
+}
+function withheldFromRun(policy) {
+  return new Set(policy.claims.filter((key) => !policy.injects.includes(key)));
+}
+function stripFrameworkOnlyOptions(options, withheld) {
+  if (withheld.size === 0 || !isRecord(options)) return options;
+  const entries = Object.entries(options);
+  if (!entries.some(([key]) => withheld.has(key))) return options;
+  return Object.fromEntries(entries.filter(([key]) => !withheld.has(key)));
+}
+function parseOrThrow2(schema, input, adaptError) {
+  const result = schema.safeParse(input);
+  if (result.success) return result.data;
+  throw toCoreError(result.error, input, adaptError);
+}
+function toCoreError(error, input, adaptError) {
+  const messages = error.issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.join(".") : "input";
+    return `${path}: ${issue.message}`;
+  });
+  return createCoreError(
+    {
+      code: CoreErrorCode.Validation,
+      message: `Validation failed:
+  ${messages.join("\n  ")}`,
+      details: { zodErrors: error.issues, input }
+    },
+    adaptError
+  );
+}
 function createAsyncContext() {
   let store = null;
   try {
@@ -732,7 +867,15 @@ function normalizeError(error, adaptError) {
   );
 }
 function createFunction(coreFn, options) {
-  const { sdk, schema, name, annotator, getDeprecation, getStability } = options;
+  const {
+    sdk,
+    schema,
+    name,
+    annotator,
+    frameworkOptions,
+    getDeprecation,
+    getStability
+  } = options;
   const functionName = name || coreFn.name;
   const namedFunctions = {
     [functionName]: async function(callOptions) {
@@ -768,25 +911,15 @@ function createFunction(coreFn, options) {
         };
         hooks?.onMethodStart?.({ ...hookBase });
         try {
-          let result;
-          if (schema) {
-            const validatedOptions = validateOptions(
-              schema,
-              normalizedOptions,
-              {
-                adaptError
-              }
-            );
-            result = await coreFn(
-              {
-                ...normalizedOptions,
-                ...validatedOptions
-              },
-              context
-            );
-          } else {
-            result = await coreFn(normalizedOptions, context);
-          }
+          const parsed = parseCallOptions(normalizedOptions, {
+            schema,
+            policy: frameworkOptions,
+            adaptError
+          });
+          const result = await coreFn(
+            mergeCallOptions(parsed),
+            context
+          );
           hooks?.onMethodEnd?.({
             ...hookBase,
             durationMs: Date.now() - startTime
@@ -907,7 +1040,7 @@ function createPageFunction(coreFn, {
             `${functionName}: paginated result must be exactly { data: TItem[], nextCursor? } (produced by the handler or its \`adaptPage\`); got keys [${page && typeof page === "object" ? Object.keys(page).join(", ") : typeof page}]. If the handler returns a raw shape, set \`adaptPage\` to translate it; if \`adaptPage\` already runs, it must return only \`data\`/\`nextCursor\`.`
           );
         }
-        return finalizePage ? finalizePage(page) : page;
+        return finalizePage ? finalizePage(page, options) : page;
       } catch (error) {
         throw normalizeError(
           error,
@@ -927,6 +1060,7 @@ function createPaginatedFunction(coreFn, options) {
     adaptPage,
     annotator,
     finalizePage,
+    frameworkOptions,
     getDeprecation,
     getStability
   } = options;
@@ -970,10 +1104,13 @@ function createPaginatedFunction(coreFn, options) {
         };
         hooks?.onMethodStart?.({ ...hookBase });
         try {
-          const validatedOptions = {
-            ...normalizedOptions,
-            ...schema ? createValidator(schema, { adaptError })(normalizedOptions) : normalizedOptions
-          };
+          const validatedOptions = mergeCallOptions(
+            parseCallOptions(normalizedOptions, {
+              schema,
+              policy: frameworkOptions,
+              adaptError
+            })
+          );
           const pageSize = validatedOptions.pageSize ?? defaultPageSize;
           const optimizedOptions = {
             ...validatedOptions,
@@ -1097,6 +1234,10 @@ function createPaginatedPluginMethod(sdk, config) {
     sdk,
     schema: inputSchema,
     name,
+    // The page loop reads the page controls out of the call object, so a
+    // handler's schema does not have to declare them. It reads nothing else:
+    // no legacy handler honors the caller's output skip.
+    frameworkOptions: PAGE_FRAMEWORK_OPTIONS,
     defaultPageSize,
     adaptPage
   });
@@ -1338,6 +1479,7 @@ function buildPluginStack(head, callerLabel) {
   };
   return stack;
 }
+var CONTEXT = Symbol.for("kitcore.context");
 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) };
@@ -1442,7 +1584,12 @@ function collectDynamicMembers(members) {
     };
   });
 }
-function defineMethod(config) {
+function defineMethod(configOrRef, refConfig) {
+  const config = refConfig === void 0 ? configOrRef : {
+    ...refConfig,
+    name: configOrRef.name,
+    namespace: configOrRef.namespace
+  };
   const deps = normalizeImports(config.imports);
   return {
     pluginType: "method",
@@ -1465,8 +1612,27 @@ function defineMethod(config) {
     run: config.run
   };
 }
-function defineMethodOverride(config) {
-  const { target, namespace, ...rest } = config;
+var OVERRIDABLE = [
+  "description",
+  "categories",
+  "itemType",
+  "returnType",
+  "packages",
+  "experimental",
+  "deprecation",
+  "supportsJsonOutput"
+];
+function assertOverridable(target, fields) {
+  const offered = Object.keys(fields).filter(
+    (key) => !OVERRIDABLE.includes(key)
+  );
+  if (offered.length === 0) return;
+  throw new Error(
+    `defineOverride("${target}"): cannot override ${offered.join(", ")}. An override changes how a surface presents a method, never what it does. The method's declared type is fixed at \`defineMethod\` and nothing re-checks it afterwards, so patching behavior here would let a call fail against a contract its own return type says it satisfies. Overridable: ${OVERRIDABLE.join(", ")}.`
+  );
+}
+function buildOverride(target, namespace, fields) {
+  assertOverridable(target, fields);
   return {
     pluginType: "method-override",
     name: `override:${target}`,
@@ -1474,12 +1640,34 @@ function defineMethodOverride(config) {
     target,
     imports: [],
     importBindings: [],
-    meta: collectLeafMeta(rest)
+    meta: collectLeafMeta(fields)
   };
 }
+function defineOverride(ref, config = {}) {
+  const { namespace, ...fields } = config;
+  return buildOverride(ref.id, namespace, fields);
+}
+function defineMethodOverride(config) {
+  logDeprecation(
+    "defineMethodOverride({ target }) is deprecated. Use defineOverride(method, { ... }), which takes the method or its declareMethod stand-in."
+  );
+  const { target, namespace, ...fields } = config;
+  return buildOverride(target, namespace, fields);
+}
+function assertRequirementPaths(requirements) {
+  if (!requirements) return;
+  for (const requirement of requirements) {
+    if (typeof requirement !== "string" && requirement.length === 0) {
+      throw new Error(
+        "defineResolver: a requireParameters path must name at least one segment. An empty path names no parameter, and the engine would read it as already satisfied."
+      );
+    }
+  }
+}
 function defineResolver(config) {
   const deps = normalizeImports(config.imports);
   const base = { imports: deps.plugins, importBindings: deps.bindings };
+  assertRequirementPaths(config.requireParameters);
   const gates = {
     requireParameters: config.requireParameters
   };
@@ -1560,21 +1748,26 @@ function declareMethod(config) {
     }
   };
 }
-function defineProperty(config) {
-  const deps = normalizeImports(config.imports);
+function defineProperty(config, refConfig) {
+  const cfg = refConfig === void 0 ? config : {
+    ...refConfig,
+    name: config.name,
+    namespace: config.namespace
+  };
+  const deps = normalizeImports(cfg.imports);
   return {
     pluginType: "property",
-    name: config.name,
-    namespace: config.namespace,
-    id: makeId(config.name, config.namespace),
+    name: cfg.name,
+    namespace: cfg.namespace,
+    id: makeId(cfg.name, cfg.namespace),
     imports: deps.plugins,
     importBindings: deps.bindings,
-    setup: config.setup,
-    dispose: config.dispose,
-    value: config.value,
-    get: config.get,
-    meta: collectLeafMeta(config),
-    dynamicMembers: collectDynamicMembers(config.dynamicMembers)
+    setup: cfg.setup,
+    dispose: cfg.dispose,
+    value: cfg.value,
+    get: cfg.get,
+    meta: collectLeafMeta(cfg),
+    dynamicMembers: collectDynamicMembers(cfg.dynamicMembers)
   };
 }
 function declareProperty(config) {
@@ -1869,6 +2062,34 @@ function collectSurfaceProjection(context, formatterSdk) {
   }
   return { meta, formatters, resolvers, positional, skipInputValidation };
 }
+var REGISTRY_CACHE = Symbol.for("kitcore.registryCache");
+function freezeContainers(registry) {
+  Object.freeze(registry.functions);
+  for (const category of registry.categories) {
+    Object.freeze(category.functions);
+    Object.freeze(category);
+  }
+  Object.freeze(registry.categories);
+  return Object.freeze(registry);
+}
+function getCachedRegistry(context, packageFilter) {
+  const key = packageFilter ?? "";
+  const caching = context;
+  let byFilter = caching[REGISTRY_CACHE];
+  if (!byFilter) {
+    byFilter = /* @__PURE__ */ new Map();
+    caching[REGISTRY_CACHE] = byFilter;
+  }
+  let registry = byFilter.get(key);
+  if (!registry) {
+    registry = freezeContainers(buildSurfaceRegistry(context, packageFilter));
+    byFilter.set(key, registry);
+  }
+  return registry;
+}
+function invalidateRegistryCache(context) {
+  delete context[REGISTRY_CACHE];
+}
 function buildSurfaceRegistry(context, packageFilter) {
   const surface = {};
   for (const [binding, id] of Object.entries(context.surface)) {
@@ -1876,9 +2097,11 @@ function buildSurfaceRegistry(context, packageFilter) {
     if (!entry || entry.pluginType === "aggregate") continue;
     surface[binding] = entry.pluginType === "property" && entry.getValue ? entry.getValue() : entry.value;
   }
+  const projection = collectSurfaceProjection(context, surface);
+  Object.assign(projection.meta, context.meta);
   return buildRegistry({
     sdk: surface,
-    ...collectSurfaceProjection(context, surface),
+    ...projection,
     packageFilter
   });
 }
@@ -1897,9 +2120,9 @@ var getRegistryPlugin = defineMethod({
   namespace: "kitcore",
   imports: [dangerousContextPlugin],
   inputSchema: zod.z.object({ package: zod.z.string().optional() }).optional(),
-  run: ({ imports, input }) => buildSurfaceRegistry(imports.context, input?.package)
+  run: ({ imports, input }) => getCachedRegistry(imports.context, input?.package)
 });
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function diffDroppedPaths(raw, parsed, prefix = "") {
@@ -1922,7 +2145,7 @@ function walkDroppedPaths(raw, parsed, prefix, out) {
     }
     return;
   }
-  if (isRecord(raw) && isRecord(parsed)) {
+  if (isRecord2(raw) && isRecord2(parsed)) {
     for (const key of Object.keys(raw)) {
       const path = prefix ? `${prefix}.${key}` : key;
       if (!(key in parsed)) {
@@ -1934,7 +2157,22 @@ function walkDroppedPaths(raw, parsed, prefix, out) {
     return;
   }
 }
-function parseOutput(schema, value, policy, locator) {
+var SKIP_OUTPUT_DATA_VALIDATION = "skipOutputDataValidation";
+function readSkipOutputDataValidation(options) {
+  return isRecord2(options) && options[SKIP_OUTPUT_DATA_VALIDATION] === true;
+}
+function resolveValidatingSchema(policy) {
+  if (policy.skipOutputValidation || policy.skippedByCaller) return void 0;
+  return policy.outputSchema;
+}
+function shouldReport(policy) {
+  return policy.skippedByCaller === true && policy.outputSchema !== void 0 && !policy.skipOutputValidation;
+}
+function parseOutput(schema, value, policy, {
+  locator,
+  hint,
+  callerCanSkip = true
+} = {}) {
   const result = schema.safeParse(value);
   if (result.success) return result.data;
   const issues = result.error.issues.map((issue) => {
@@ -1949,57 +2187,134 @@ function parseOutput(schema, value, policy, locator) {
       message: `Output validation failed${subject}${at}:
   ${issues.join("\n  ")}
 
-The response does not match the method's \`outputSchema\`. Correct the schema, or set \`skipOutputValidation: true\` on the method to pass the response through unvalidated.`,
+` + (hint ? `${hint}
+
+` : "") + `The response does not match the method's \`outputSchema\`. Correct the schema, or set \`skipOutputValidation: true\` on the method to pass the response through unvalidated.` + (callerCanSkip ? ` A caller who cannot change the method can pass \`skipOutputDataValidation: true\` with the input to bypass this one call.` : ``),
       details: { zodErrors: result.error.issues, output: value }
     },
     policy.adaptError
   );
 }
 function applyItemOutputPolicy(result, policy) {
-  const schema = policy.outputSchema;
-  if (!schema || policy.skipOutputValidation) return result;
-  if (!isRecord(result) || !("data" in result)) return result;
+  const schema = resolveValidatingSchema(policy);
+  const report = shouldReport(policy);
+  if (!schema && !report) return result;
+  if (!isRecord2(result) || !("data" in result)) return result;
+  if (!schema) {
+    return {
+      ...result,
+      meta: withOutputValidation(result.meta, { skipped: true })
+    };
+  }
   const data = parseOutput(schema, result.data, policy);
+  const validation = buildValidatedReport({
+    policy,
+    before: result.data,
+    after: data
+  });
   const next = { ...result, data };
-  if (policy.includeOutputValidationDroppedPaths) {
-    const droppedPaths = diffDroppedPaths(result.data, data);
-    if (droppedPaths.length > 0) {
-      next.meta = withOutputValidation(result.meta, droppedPaths);
-    }
-  }
+  if (validation) next.meta = withOutputValidation(result.meta, validation);
   return next;
 }
-function withOutputValidation(existing, droppedPaths) {
-  const base = isRecord(existing) ? existing : {};
-  return { ...base, outputValidation: { droppedPaths } };
+function applyRawOutputPolicy(result, policy) {
+  const schema = resolveValidatingSchema(policy);
+  if (!schema) return result;
+  const looksLikeEnvelope = isRecord2(result) && "data" in result;
+  parseOutput(schema, result, policy, {
+    hint: looksLikeEnvelope ? 'This returned a `{ data }` envelope, and with no `output` mode the schema is matched against the WHOLE return. Did you mean `output: "item"` (or `"list"`)?' : void 0,
+    // Raw reserves nothing in the caller's call object, so there is no per-call
+    // skip to point at. Offering one would be advice that does nothing.
+    callerCanSkip: false
+  });
+  return result;
+}
+function withOutputValidation(existing, outputDataValidation) {
+  const base = isRecord2(existing) ? existing : {};
+  const deprecated = outputDataValidation.skipped === false && outputDataValidation.droppedPaths ? {
+    outputValidation: { droppedPaths: outputDataValidation.droppedPaths }
+  } : {};
+  return { ...base, outputDataValidation, ...deprecated };
+}
+function buildValidatedReport({
+  policy,
+  before,
+  after
+}) {
+  const droppedPaths = policy.includeOutputValidationDroppedPaths ? diffDroppedPaths(before, after) : [];
+  if (droppedPaths.length === 0) return void 0;
+  return {
+    skipped: false,
+    droppedPaths,
+    instruction: `Some fields were removed from \`data\` by output validation. To receive the raw, unvalidated result instead, set \`${SKIP_OUTPUT_DATA_VALIDATION}\`.`
+  };
 }
 function applyListOutputPolicy(page, policy) {
-  const schema = policy.outputSchema;
-  if (!schema || policy.skipOutputValidation) return page;
+  const schema = resolveValidatingSchema(policy);
+  const report = shouldReport(policy);
+  if (!schema && !report) return page;
+  if (!schema) {
+    return {
+      ...page,
+      meta: withOutputValidation(page.meta, { skipped: true })
+    };
+  }
   const data = page.data.map(
-    (item, index) => parseOutput(schema, item, policy, `data[${index}]`)
+    (item, index) => parseOutput(schema, item, policy, { locator: `data[${index}]` })
   );
+  const validation = buildValidatedReport({
+    policy,
+    before: page.data,
+    after: data
+  });
   const next = { ...page, data };
-  if (policy.includeOutputValidationDroppedPaths) {
-    const droppedPaths = diffDroppedPaths(page.data, data);
-    if (droppedPaths.length > 0) {
-      next.meta = { ...page.meta, outputValidation: { droppedPaths } };
-    }
-  }
+  if (validation)
+    next.meta = withOutputValidation(
+      page.meta,
+      validation
+    );
   return next;
 }
 var FRAMEWORK_CONFIGURATION_IDS = /* @__PURE__ */ new Set([
   CORE_OPTIONS_ID
 ]);
+function isPromiseLike(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
 function normalizeOutput(output) {
   if (output === void 0) return { type: "raw" };
   if (typeof output === "string") return { type: output };
   return output;
 }
-var CONTEXT = Symbol.for("kitcore.context");
 function getContext(sdk) {
   return sdk[CONTEXT];
 }
+function assertDynamicMemberRoot(entry) {
+  if (!entry.dynamicMembers?.length) return;
+  const value = entry.getValue ? entry.getValue() : entry.value;
+  if (typeof value === "object" && value !== null) return;
+  throw new Error(
+    `Property "${entry.name}" declares dynamicMembers, so its value must be an object when the SDK is built; got ${value === null ? "null" : typeof value}. Build the root in \`setup\` and return it from \`get\`, so members like "${entry.dynamicMembers[0].name}" are reportable from the first registry read.`
+  );
+}
+function getRegistry(sdk, packageFilter) {
+  if (typeof sdk !== "object" && typeof sdk !== "function" || sdk === null)
+    throw createNoRegistryError();
+  const context = getContext(sdk);
+  if (context?.surface) return getCachedRegistry(context, packageFilter);
+  const surfaced = sdk.getRegistry;
+  if (typeof surfaced === "function") {
+    return surfaced.call(
+      sdk,
+      void 0
+    );
+  }
+  throw createNoRegistryError();
+}
+function createNoRegistryError() {
+  return new Error(
+    "getRegistry: sdk has no kitcore context and no surfaced getRegistry()."
+  );
+}
 function isResolverRef(value) {
   return "ref" in value;
 }
@@ -2219,8 +2534,9 @@ function bindValue({
   frameworkOrigin = false
 }) {
   if (entry.pluginType === "property" && entry.getValue) {
+    const getValue = entry.getValue;
     Object.defineProperty(target, key, {
-      get: entry.getValue,
+      get: ctx ? () => getValue(ctx) : getValue,
       enumerable: true,
       configurable: true
     });
@@ -2504,22 +2820,16 @@ function runLegacyPass(descriptors, context) {
     Object.assign(context, contextRest);
     context.hooks = buildHooks(context.hooks, hooks);
     const exports = mirrorLegacyRootKeys(context, rootKeys, meta);
+    for (const name of Object.keys(rootKeys)) context.surface[name] = name;
     if (!("getRegistry" in exports)) {
-      let getRegistry2 = function(options) {
-        const sdk = this ?? exports;
-        const projection = collectSurfaceProjection(context, sdk);
-        Object.assign(projection.meta, context.meta);
-        return buildRegistry({
-          sdk,
-          ...projection,
-          packageFilter: options?.package
-        });
+      let getRegistry3 = function(options) {
+        return getCachedRegistry(context, options?.package);
       };
-      exports.getRegistry = getRegistry2;
+      exports.getRegistry = getRegistry3;
       plugins.getRegistry = {
         pluginType: "method",
         name: "getRegistry",
-        value: getRegistry2,
+        value: getRegistry3,
         chain: []
       };
     }
@@ -2583,50 +2893,73 @@ function buildMethodEntries(descriptors, context, states) {
     const sdk = { context };
     const methodAnnotator = descriptor.annotator;
     const boundAnnotator = methodAnnotator ? (input) => methodAnnotator({ input }) : void 0;
-    const outputPolicy = () => {
+    const outputPolicy = (callOptions) => {
       const core = resolveCoreOptions(context);
       return {
         outputSchema: descriptor.meta?.outputSchema,
         skipOutputValidation: descriptor.skipOutputValidation,
+        skippedByCaller: readSkipOutputDataValidation(callOptions),
         includeOutputValidationDroppedPaths: core?.includeOutputValidationDroppedPaths,
         methodName: descriptor.name,
         adaptError: core?.adaptError
       };
     };
+    const frameworkOptions = out.type === "list" ? LIST_FRAMEWORK_OPTIONS : ITEM_FRAMEWORK_OPTIONS;
+    const withheld = withheldFromRun(frameworkOptions);
     if (out.type === "list") {
       entry.value = createPaginatedFunction(
-        fold(callRun),
+        fold(
+          (input, ctx) => callRun(stripFrameworkOnlyOptions(input, withheld), ctx)
+        ),
         {
           sdk,
           schema: descriptor.inputSchema,
           name: descriptor.name,
+          frameworkOptions,
           defaultPageSize: out.defaultPageSize,
           adaptPage: out.adaptPage,
           annotator: boundAnnotator,
           // Validate + strip each item against the item `outputSchema`
           // (item mode's sibling); dropped paths surface as `[].x` in the page's
           // `meta`, unioned across items.
-          finalizePage: (page) => applyListOutputPolicy(page, outputPolicy()),
+          finalizePage: (page, callOptions) => applyListOutputPolicy(page, outputPolicy(callOptions)),
           getDeprecation: () => entry.meta?.deprecation,
           getStability: () => entry.meta ? normalizeStability(entry.meta) : void 0
         }
       );
     } else if (out.type === "item") {
-      const itemCore = async (input, ctx) => applyItemOutputPolicy(await callRun(input, ctx), outputPolicy());
+      const itemCore = async (input, ctx) => applyItemOutputPolicy(
+        await callRun(stripFrameworkOnlyOptions(input, withheld), ctx),
+        outputPolicy(input)
+      );
       entry.value = createFunction(
         fold(itemCore),
         {
           sdk,
           schema: descriptor.inputSchema,
           name: descriptor.name,
+          frameworkOptions,
           annotator: boundAnnotator,
           getDeprecation: () => entry.meta?.deprecation,
           getStability: () => entry.meta ? normalizeStability(entry.meta) : void 0
         }
       );
     } else {
+      const rawValidates = descriptor.meta?.outputSchema !== void 0 && !descriptor.skipOutputValidation;
+      const validateRaw = (out2) => {
+        const policy = outputPolicy(void 0);
+        if (isPromiseLike(out2)) {
+          return Promise.resolve(out2).then(
+            (value) => applyRawOutputPolicy(value, policy)
+          );
+        }
+        return applyRawOutputPolicy(out2, policy);
+      };
       entry.value = createRawFunction(
-        (input, ctx) => fold(callRun)(input, ctx),
+        (input, ctx) => {
+          const out2 = fold(callRun)(input, ctx);
+          return rawValidates ? validateRaw(out2) : out2;
+        },
         {
           sdk,
           name: descriptor.name,
@@ -2758,9 +3091,14 @@ function buildEagerArtifacts(descriptors, context, states) {
         plugins[id] = {
           pluginType: "property",
           name: descriptor.name,
-          getValue: () => get({
-            imports: buildImports({ plugins, importBindings }),
-            state: states.get(id)
+          getValue: (callContext) => get({
+            imports: buildImports({
+              plugins,
+              importBindings,
+              ctx: callContext
+            }),
+            state: states.get(id),
+            callContext
           }),
           meta: descriptor.meta,
           dynamicMembers: descriptor.dynamicMembers
@@ -2774,6 +3112,7 @@ function buildEagerArtifacts(descriptors, context, states) {
           dynamicMembers: descriptor.dynamicMembers
         };
       }
+      assertDynamicMemberRoot(plugins[id]);
     }
     recordDisposer();
     building.delete(id);
@@ -2997,34 +3336,29 @@ function addModelPlugin(sdk, plugin, options = {}) {
   }
 }
 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;
+  const record = sdk;
+  const context = getContext(record);
+  try {
+    if (typeof plugin === "function") {
+      const contribution = applyPluginToSdk(
+        record,
+        plugin,
+        options ?? {}
+      );
+      if (context) {
+        mirrorLegacyRootKeys(context, contribution.rootKeys, contribution.meta);
+        for (const name of Object.keys(contribution.rootKeys)) {
+          context.surface[name] = name;
+        }
       }
+    } else if (plugin.pluginType === "method-override") {
+      applyMethodOverride(context, plugin);
+    } else {
+      addModelPlugin(record, plugin, options ?? {});
     }
-    return;
-  }
-  if (plugin.pluginType === "method-override") {
-    applyMethodOverride(
-      getContext(sdk),
-      plugin
-    );
-    return;
+  } finally {
+    if (context) invalidateRegistryCache(context);
   }
-  addModelPlugin(
-    sdk,
-    plugin,
-    options ?? {}
-  );
 }
 var CORE_SIGNAL_SYMBOL = Symbol.for("kitcore.signal");
 var CoreSignal = class extends Error {
@@ -3054,24 +3388,6 @@ var CoreCancelledSignal = class extends CoreSignal {
 function isCoreCancelledSignal(value) {
   return isCoreSignal(value) && value.code === "CANCELLED";
 }
-function unwrap(schema) {
-  let inner = schema;
-  let required = true;
-  for (; ; ) {
-    if (inner instanceof zod.z.ZodOptional) {
-      required = false;
-      inner = inner._zod.def.innerType;
-    } else if (inner instanceof zod.z.ZodDefault) {
-      required = false;
-      inner = inner._zod.def.innerType;
-    } else if (inner instanceof zod.z.ZodNullable) {
-      inner = inner._zod.def.innerType;
-    } else {
-      break;
-    }
-  }
-  return { inner, required };
-}
 function valueTypeOf(inner) {
   if (inner instanceof zod.z.ZodString) return "string";
   if (inner instanceof zod.z.ZodNumber) return "number";
@@ -3089,19 +3405,15 @@ function staticChoicesOf(inner) {
   }
   return void 0;
 }
-function objectShape(schema) {
-  const canonical = canonicalInputSchema(schema);
-  const { inner } = canonical ? unwrap(canonical) : { inner: void 0 };
-  if (inner instanceof zod.z.ZodObject) {
-    return inner.shape;
-  }
-  return void 0;
-}
 function topoOrder2(specs) {
   const byName = new Map(specs.map((s) => [s.name, s]));
   const placed = /* @__PURE__ */ new Set();
   const ordered = [];
-  const isReady = (spec) => spec.requires.every((r) => !byName.has(r) || placed.has(r));
+  const topLevelNameOf = (r) => typeof r === "string" ? r : r.length === 1 && typeof r[0] === "string" ? r[0] : void 0;
+  const isReady = (spec) => spec.requires.every((r) => {
+    const name = topLevelNameOf(r);
+    return name === void 0 || !byName.has(name) || placed.has(name);
+  });
   for (; ; ) {
     const next = specs.find((s) => !placed.has(s.name) && isReady(s));
     if (!next) break;
@@ -3112,7 +3424,7 @@ function topoOrder2(specs) {
   return ordered;
 }
 function planParameters(entry) {
-  const shape = objectShape(entry.inputSchema);
+  const shape = objectShapeOf(entry.inputSchema);
   const resolvers = entry.resolvers ?? {};
   const names = shape ? [
     ...Object.keys(shape),
@@ -3122,7 +3434,7 @@ function planParameters(entry) {
   ] : Object.keys(resolvers);
   const specs = names.map((name) => {
     const field = shape?.[name];
-    const { inner, required } = field ? unwrap(field) : { inner: void 0, required: false };
+    const { inner, required } = field ? unwrapSchema(field) : { inner: void 0, required: false };
     const resolver = resolvers[name];
     return {
       name,
@@ -3765,9 +4077,13 @@ async function findNext(ctx, state, path = []) {
   const hasAskableRequired = children.some((c) => c.required && asksUser(c));
   for (const leaf of ordered) {
     const childPath = [...path, leaf.name];
-    if (!leaf.requires.every(
-      (r) => container[r] !== void 0 || getAtPath(state.resolved, [r]) !== void 0 || isSettled(state, [...path, r]) || isSettled(state, [r])
-    )) {
+    if (!leaf.requires.every((r) => {
+      if (typeof r !== "string") {
+        if (getAtPath(state.resolved, [...r]) !== void 0) return true;
+        return r.some((_, index) => isSettled(state, r.slice(0, index + 1)));
+      }
+      return container[r] !== void 0 || getAtPath(state.resolved, [r]) !== void 0 || isSettled(state, [...path, r]) || isSettled(state, [r]);
+    })) {
       continue;
     }
     const inArrayItem = path.some((segment) => typeof segment === "number");
@@ -4207,7 +4523,7 @@ function projectMethod(entry) {
 }
 function createController(sdk) {
   function entryFor(method) {
-    const entry = sdk.getRegistry().functions.find((f) => f.name === method);
+    const entry = getRegistry(sdk).functions.find((f) => f.name === method);
     if (!entry) throw new Error(`unknown method "${method}"`);
     return entry;
   }
@@ -4246,7 +4562,7 @@ function createController(sdk) {
     throw new Error(`invalid input for "${method}": ${detail}`);
   };
   const listMethods = () => ({
-    data: sdk.getRegistry().functions.map(projectSummary)
+    data: getRegistry(sdk).functions.map(projectSummary)
   });
   const getMethod = ({ method }) => ({
     data: projectMethod(entryFor(method))
@@ -5666,6 +5982,11 @@ function createSemaphore(maxPermits) {
     }
   };
 }
+
+// src/api/correlation.ts
+var CORRELATION_CALL_ID = Symbol(
+  "zapier.correlationCallId"
+);
 var ClientCredentialsObjectSchema = zod.z.object({
   type: zod.z.enum(["client_credentials"]).optional().meta({ internal: true }),
   clientId: zod.z.string().describe("OAuth client ID for authentication.").meta({ valueHint: "id" }),
@@ -6565,13 +6886,13 @@ function sniffDeprecationNotice({
       payload: { ...payload },
       timestamp: Date.now()
     });
-    if (isPromiseLike(maybePromise)) {
+    if (isPromiseLike2(maybePromise)) {
       void Promise.resolve(maybePromise).catch(() => {
       });
     }
   }
 }
-function isPromiseLike(value) {
+function isPromiseLike2(value) {
   return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
 }
 function parseDeprecationDate(value) {
@@ -6582,7 +6903,7 @@ function parseDeprecationDate(value) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.98.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.99.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -6844,14 +7165,15 @@ var ZapierApiClient = class {
      * directly and drifting.
      */
     this.rawFetchUrl = async (url, init, pathConfig2) => {
-      if (init?.body && (isPlainObject(init.body) || Array.isArray(init.body))) {
-        init.body = JSON.stringify(init.body);
+      const { [CORRELATION_CALL_ID]: callId, ...fetchInit } = init ?? {};
+      if (fetchInit.body && (isPlainObject(fetchInit.body) || Array.isArray(fetchInit.body))) {
+        fetchInit.body = JSON.stringify(fetchInit.body);
       }
       const builtHeaders = await this.buildHeaders(
-        init,
+        fetchInit,
         pathConfig2
       );
-      const inputHeaders = new Headers(init?.headers ?? {});
+      const inputHeaders = new Headers(fetchInit.headers ?? {});
       const mergedHeaders = new Headers();
       builtHeaders.forEach((value, key) => {
         mergedHeaders.set(key, value);
@@ -6859,11 +7181,11 @@ var ZapierApiClient = class {
       inputHeaders.forEach((value, key) => {
         mergedHeaders.set(key, value);
       });
-      this.applyTelemetryHeaders(mergedHeaders);
+      this.applyTelemetryHeaders({ headers: mergedHeaders, callId });
       let retries = 0;
       while (true) {
         const response = await this.options.fetch(url, {
-          ...init,
+          ...fetchInit,
           headers: mergedHeaders
         });
         if (response.status !== 429) {
@@ -6984,12 +7306,13 @@ var ZapierApiClient = class {
         );
         const askStatementIds = askStatementIdsHeader ? JSON.parse(askStatementIdsHeader) : void 0;
         try {
-          await this.runOneApprovalRound(
-            approvalContext,
-            approvalMode,
-            init?.signal ?? void 0,
-            askStatementIds
-          );
+          await this.runOneApprovalRound({
+            buildContext: approvalContext,
+            mode: approvalMode,
+            signal: init?.signal ?? void 0,
+            askStatementIds,
+            callId: init?.[CORRELATION_CALL_ID]
+          });
         } catch (error) {
           return { response, approvalRoundError: error };
         }
@@ -7131,7 +7454,8 @@ var ZapierApiClient = class {
           method: "GET",
           searchParams: options.searchParams,
           authRequired: options.authRequired,
-          signal: options.signal
+          signal: options.signal,
+          [CORRELATION_CALL_ID]: options[CORRELATION_CALL_ID]
         }),
         initialDelay: options.initialDelayMilliseconds ?? options.initialDelay,
         timeoutMs: options.timeoutMilliseconds ?? options.timeoutMs,
@@ -7426,7 +7750,10 @@ var ZapierApiClient = class {
   // gateway now expects) and the legacy `x-zapier-*` names. The legacy names are
   // kept for backward compatibility with consumers that haven't migrated yet;
   // they can be removed once nothing reads them.
-  applyTelemetryHeaders(headers) {
+  applyTelemetryHeaders({
+    headers,
+    callId
+  }) {
     headers.set("zapier-sdk-version", SDK_VERSION);
     headers.set("x-zapier-sdk-version", SDK_VERSION);
     const sdkService = getZapierSdkService();
@@ -7449,6 +7776,11 @@ var ZapierApiClient = class {
         headers.set("zapier-sdk-package-operation", packageOperation);
       }
     }
+    if (callId) {
+      headers.set("zapier-correlation-id", callId);
+    } else {
+      headers.delete("zapier-correlation-id");
+    }
   }
   // Helper to perform HTTP requests with JSON handling
   async fetchJson(method, path, data, options = {}) {
@@ -7591,7 +7923,13 @@ var ZapierApiClient = class {
    * Caller is responsible for passing a non-"disabled" mode; this method
    * unconditionally creates an approval.
    */
-  async runOneApprovalRound(buildContext, mode, signal, askStatementIds) {
+  async runOneApprovalRound({
+    buildContext,
+    mode,
+    signal,
+    askStatementIds,
+    callId
+  }) {
     const context = buildContext();
     let approvalResponse;
     try {
@@ -7605,7 +7943,8 @@ var ZapierApiClient = class {
           context,
           ...askStatementIds?.length ? { ask_statement_ids: askStatementIds } : {}
         }),
-        signal
+        signal,
+        [CORRELATION_CALL_ID]: callId
       });
     } catch (err) {
       if (isAbortError(err)) throw err;
@@ -7741,7 +8080,10 @@ var ZapierApiClient = class {
         approvalId: approval.id,
         streamUrl,
         signal: streamAbortController.signal,
-        stream: (url, streamInit) => this.streamTrustedJsonUrl(url, streamInit),
+        stream: (url, streamInit) => this.streamTrustedJsonUrl(url, {
+          ...streamInit,
+          [CORRELATION_CALL_ID]: callId
+        }),
         emitEvent: (type, payload) => this.emitEvent(type, payload)
       });
     }
@@ -7750,7 +8092,8 @@ var ZapierApiClient = class {
       () => this.rawFetchUrl(approval.poll_url, {
         method: "GET",
         headers: { Accept: "application/json" },
-        signal
+        signal,
+        [CORRELATION_CALL_ID]: callId
       })
     );
     const pollApprovalUntilComplete = async (isPending, deadlineMs = approvalDeadline) => {
@@ -7942,6 +8285,23 @@ var API_ID = "zapier/api";
 var apiPluginRef = declareProperty({
   id: API_ID
 });
+function withCorrelationId({
+  client,
+  callId
+}) {
+  const stamp = (options) => ({ ...options, [CORRELATION_CALL_ID]: callId });
+  return {
+    get: (path, options) => client.get(path, stamp(options)),
+    post: (path, data, options) => client.post(path, data, stamp(options)),
+    put: (path, data, options) => client.put(path, data, stamp(options)),
+    patch: (path, data, options) => client.patch(path, data, stamp(options)),
+    delete: (path, data, options) => client.delete(path, data, stamp(options)),
+    poll: (path, options) => client.poll(path, stamp(options)),
+    fetch: (path, init) => client.fetch(path, stamp(init)),
+    fetchStream: (path, init) => client.fetchStream(path, stamp(init)),
+    fetchJsonStream: (path, init) => client.fetchJsonStream(path, stamp(init))
+  };
+}
 var apiPlugin = defineProperty({
   namespace: "zapier",
   name: "api",
@@ -7982,7 +8342,7 @@ var apiPlugin = defineProperty({
       callerPackage
     });
   },
-  get: ({ state }) => state
+  get: ({ state, callContext }) => callContext?.callId ? withCorrelationId({ client: state, callId: callContext.callId }) : state
 });
 var RESOLVE_CREDENTIALS_ID = "zapier/resolveCredentials";
 var resolveCredentialsPluginRef = declareProperty({ id: RESOLVE_CREDENTIALS_ID });
@@ -8543,8 +8903,11 @@ var manifestPlugin = defineProperty({
   namespace: "zapier",
   name: "manifest",
   imports: [sdkOptionsPluginRef, apiPluginRef],
+  // Deliberately does not read `imports.api`: at build time that resolves to the
+  // bare shared client, and capturing it here would strip the correlation id off
+  // every slug-resolution request. `get` supplies the reading call's client
+  // instead.
   setup: ({ imports }) => {
-    const api = imports.api;
     const { manifestPath = DEFAULT_CONFIG_PATH, manifest } = imports.sdkOptions ?? {};
     let resolvedManifest;
     async function resolveManifest() {
@@ -8562,7 +8925,10 @@ var manifestPlugin = defineProperty({
       }
       return resolvedManifest;
     };
-    const getVersionedImplementationId = async (appKey) => {
+    const getVersionedImplementationId = async ({
+      appKey,
+      api
+    }) => {
       const resolvedApps = await resolveAppKeys({
         appKeys: [appKey],
         api,
@@ -8572,14 +8938,14 @@ var manifestPlugin = defineProperty({
       if (!resolvedApp) return null;
       return `${resolvedApp.implementationName}@${resolvedApp.version || "latest"}`;
     };
-    const updateManifestEntry = async (options) => {
-      const {
-        appKey,
-        entry,
-        configPath = DEFAULT_CONFIG_PATH,
-        skipWrite = false,
-        manifest: inputManifest
-      } = options;
+    const updateManifestEntry = async ({
+      api,
+      appKey,
+      entry,
+      configPath = DEFAULT_CONFIG_PATH,
+      skipWrite = false,
+      manifest: inputManifest
+    }) => {
       const manifest2 = inputManifest || await readManifestFromFile(configPath) || { apps: {} };
       let existingEntry = findManifestEntry({
         appKey,
@@ -8630,7 +8996,7 @@ var manifestPlugin = defineProperty({
     };
     return {
       getVersionedImplementationId,
-      resolveAppKeys: async ({ appKeys }) => resolveAppKeys({
+      resolveAppKeys: async ({ appKeys, api }) => resolveAppKeys({
         appKeys,
         api,
         manifest: await getResolvedManifest() ?? { apps: {} }
@@ -8643,7 +9009,19 @@ var manifestPlugin = defineProperty({
       updateManifestEntry
     };
   },
-  get: ({ state }) => state
+  // Bind the reading call's API client onto the slug-resolving entry points so
+  // their requests carry that call's correlation id. The manifest-only reads pass
+  // straight through.
+  get: ({ imports, state }) => {
+    const api = imports.api;
+    return {
+      getVersionedImplementationId: (appKey) => state.getVersionedImplementationId({ appKey, api }),
+      resolveAppKeys: ({ appKeys }) => state.resolveAppKeys({ appKeys, api }),
+      getResolvedManifest: state.getResolvedManifest,
+      getManifestConnections: state.getManifestConnections,
+      updateManifestEntry: (options) => state.updateManifestEntry({ ...options, api })
+    };
+  }
 });
 
 // src/plugins/connections/index.ts
@@ -15744,6 +16122,7 @@ function buildErrorEventWithContext(data, context = {}) {
 function buildMethodCalledEvent(data, context = {}) {
   return {
     ...createBaseEvent(context),
+    correlation_id: data.correlation_id ?? context.correlation_id ?? null,
     method_name: data.method_name ?? null,
     method_module: data.method_module ?? null,
     execution_duration_ms: data.execution_duration_ms,
@@ -15801,6 +16180,7 @@ function makeMethodEndHook(emitMethodCalled) {
     args,
     isPaginated,
     depth,
+    callId,
     callOrigin,
     annotations,
     durationMs,
@@ -15810,6 +16190,9 @@ function makeMethodEndHook(emitMethodCalled) {
     const metadata = readMethodMetadata(annotations);
     emitMethodCalled({
       method_name: methodName,
+      // The per-call correlation id (also the `zapier-correlation-id` header on
+      // this call's requests). Not the `call_context` surface label.
+      correlation_id: callId ?? null,
       execution_duration_ms: durationMs,
       success_flag: !error,
       error_message: error?.message ?? null,
@@ -16636,6 +17019,7 @@ exports.defineFormatter = defineFormatter;
 exports.defineLegacyMerge = defineLegacyMerge;
 exports.defineMethod = defineMethod;
 exports.defineMethodOverride = defineMethodOverride;
+exports.defineOverride = defineOverride;
 exports.definePlugin = definePlugin;
 exports.defineProperty = defineProperty;
 exports.defineResolver = defineResolver;