@zapier/kitcore 0.15.0 → 0.17.0

package/dist/index.d.mts

@@ -8,6 +8,49 @@ declare module "zod" {
     }
 }
 
+/**
+ * What the framework reports about the output it produced.
+ *
+ * `skipped` says only that THE FRAMEWORK did not parse, never that the data is
+ * unchecked: a plugin opting out with `skipOutputValidation` may still parse
+ * inside its own `run`, and several do precisely to avoid a double-parse.
+ *
+ * `droppedPaths` is what the strip removed. `null` means nothing was dropped,
+ * never "we did not look": the diff is gated on the head's
+ * `includeOutputValidationDroppedPaths`, and a report only carries paths on a
+ * path that computed them. Paths are relative to `data` in both
+ * modes (`a.b` for an item), with array elements collapsed to one `[]` segment
+ * and unioned (`[].b` on a page, `items[].b` for an array inside an item).
+ *
+ * `instruction` rides only the arm where it is actionable, telling a caller how
+ * to get the stripped fields back.
+ *
+ * Three arms, matching the connectors SDK's `OutputDataValidationMeta` exactly.
+ * That SDK is the consumer this work is heading toward, and its instruction text
+ * is agent-facing, so a divergent shape or wording would have to be translated
+ * at the boundary rather than passed through.
+ *
+ * kitcore does not currently emit the middle arm. Reporting a validated call
+ * with nothing dropped requires a surface that reports unconditionally, and
+ * kitcore only reports when there is something to say. The arm is here so the
+ * type IS connectors' type rather than a subset of it, and so a reader written
+ * against either handles both.
+ *
+ * WHETHER a report is emitted is a separate question from its shape, and it is
+ * deliberately different: connectors reports on every run, kitcore only when
+ * there is something to say (a caller's skip that changed something, or paths
+ * actually dropped with the head's `includeOutputValidationDroppedPaths` on).
+ */
+type OutputDataValidationReport = {
+    skipped: true;
+} | {
+    skipped: false;
+    droppedPaths: null;
+} | {
+    skipped: false;
+    droppedPaths: string[];
+    instruction: string;
+};
 /**
  * The response `meta` sidecar, shared by both output modes: an item method's
  * `{ data, meta }` envelope and a list method's page carry the same shape, so a
@@ -18,13 +61,20 @@ declare module "zod" {
  * the boundary attaches what belongs here.
  */
 interface ResponseMeta {
+    /** See {@link OutputDataValidationReport}. Present only when there is
+     * something to say: a caller's skip that changed something, or paths that
+     * were dropped. */
+    outputDataValidation?: OutputDataValidationReport;
     /**
-     * What output validation's strip removed from the response, present only when
-     * the head enables the `includeOutputValidationDroppedPaths` core option AND
-     * something was actually dropped. Paths are relative to `data` in both modes
-     * (`a.b` for an item), with array elements collapsed to one `[]` segment and
-     * unioned (`[].b` on a page, `items[].b` for an array inside an item), matching
-     * connectors' format.
+     * @deprecated Read `outputDataValidation` instead. Still written alongside
+     * it, with the shape and the emission rule it always had (present only when
+     * the strip actually removed something), and removed next release.
+     *
+     * No runtime deprecation warning accompanies this, unlike every other exit in
+     * the package. There is no call to attach one to: a consumer reads a property
+     * off a plain result object, and the only way to notice would be to make this
+     * a logging getter, which would then fire on anything that serializes a
+     * response.
      */
     outputValidation?: {
         droppedPaths: string[];
@@ -89,6 +139,22 @@ interface PaginatedSdkResult<TItem> extends Promise<SdkPage<TItem>> {
 }
 type PaginatedSdkFunction<TOptions, TItem> = (options: TOptions) => PaginatedSdkResult<TItem>;
 
+/**
+ * The external escape-hatch key for an SDK's context. A Symbol,
+ * not a string, so it stays off the string surface (which is exactly the root's
+ * exports) and is collision-free and clearly internal. It is attached at
+ * runtime but kept OUT of the public SDK type (a `unique symbol` in an exported
+ * type can't be named in a consumer's emitted `.d.ts`); reach it through the
+ * typed `getContext(sdk)` accessor.
+ *
+ * `Symbol.for`, not `Symbol()`: heads bundle kitcore (tsup `noExternal`), so
+ * an sdk built by one bundle's copy must still be readable by another copy's
+ * `getContext` / `resolvePlugin` (e.g. a CLI sdk inspected with helpers
+ * imported from `@zapier/zapier-sdk`). The global symbol registry makes every
+ * copy agree on the key.
+ */
+declare const CONTEXT: unique symbol;
+
 /**
  * Per-call context threaded explicitly through the method boundary in place of
  * ambient AsyncLocalStorage. It carries call identity, nesting depth, and a
@@ -301,6 +367,20 @@ declare function applyStabilityLabel({ description, stability, placement, }: {
  * Runtime validation still uses the full union; only shape reading canonicalizes.
  */
 declare function canonicalInputSchema(schema: z.ZodSchema | undefined): z.ZodSchema | undefined;
+/** Strip optional/default/nullable wrappers to the inner schema, tracking
+ * whether the wrappers made the field non-required. */
+declare function unwrapSchema(schema: z.ZodType): {
+    inner: z.ZodType;
+    required: boolean;
+};
+/**
+ * The object shape of a method's input schema, or undefined when the schema is
+ * absent or not a plain object. A required-rename union (`z.union([canonical,
+ * deprecated])`) is canonicalized to its first variant first, and
+ * optional/default/nullable wrappers are stripped, so a schema whose fields are
+ * readable at all is read rather than treated as shapeless.
+ */
+declare function objectShapeOf(schema: z.ZodSchema | undefined): Record<string, z.ZodType> | undefined;
 interface FormattedItem {
     title: string;
     /**
@@ -636,6 +716,32 @@ interface LeafMetaFields {
     aliases?: Record<string, string>;
     supportsJsonOutput?: boolean;
 }
+/**
+ * The meta an override may patch onto an already-built method.
+ *
+ * An allow-list, so a field added to {@link LeafMetaFields} later is refused
+ * until someone decides it is safe. Naming the dangerous fields instead would
+ * hand every future field to overrides by default, and the default has to be
+ * the safe one: an override changes how a surface PRESENTS a method, never what
+ * runs, what input is accepted, or what safety gate fires. Nothing re-checks
+ * the method's declared TypeScript type after `defineMethod` fixes it.
+ *
+ * What that rule rules out, and why each is dangerous rather than merely
+ * unused:
+ *
+ * - `outputSchema` decides what output validation enforces. Patching it makes
+ *   a call fail against a contract its own return type says it satisfies.
+ * - `confirm` gates a host's confirmation prompt. Patching it can drop the
+ *   prompt in front of a destructive call.
+ * - `type` reaches `confirm` indirectly: the registry derives
+ *   `confirm: m.confirm ?? (m.type === "delete" ? "delete" : undefined)`, so
+ *   moving a method off `"delete"` removes the same prompt quietly.
+ * - `aliases` maps a parameter to a CLI flag, so patching it changes which
+ *   input a caller can pass.
+ * - `skipOutputValidation` is already unreachable, being absent from
+ *   `LEAF_META_KEYS` and never folded into the projected meta.
+ */
+type OverridableMetaFields = Pick<LeafMetaFields, "description" | "categories" | "itemType" | "returnType" | "packages" | "experimental" | "deprecation" | "supportsJsonOutput">;
 /** One segment of a {@link DynamicMember} path: a literal binding/segment name,
  * or a `{ param }` placeholder for an open-ended key (rendered `{param}`). */
 type DynamicMemberSegment = string | {
@@ -689,6 +795,17 @@ interface ImportBinding {
  * `{ name: signature }` union into one `imports` object type.
  */
 type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+/**
+ * What `run` sees, given what a CALLER may pass.
+ *
+ * Subtracts exactly what the runtime strips on the way in, so the type and
+ * `stripFrameworkOnlyOptions` cannot drift. The subtraction is unconditional,
+ * matching the runtime: a method that DECLARES `maxItems` still does not
+ * receive it, because a list `run` fetches one page and the cap spans pages.
+ */
+type ItemRunInput<TInput> = Omit<TInput, "skipOutputDataValidation">;
+/** The list twin of {@link ItemRunInput}, plus the page `run` is asked for. */
+type ListRunInput<TInput> = Omit<TInput, "skipOutputDataValidation" | "maxItems"> & PageFetchInput;
 /**
  * A method's callable signature. A method with no declared input infers
  * `TInput = unknown`; make its input optional so it is callable with no
@@ -806,13 +923,31 @@ interface Field {
     required?: boolean;
     valueType?: string;
 }
+/**
+ * One entry in `requireParameters`. A bare NAME is looked up in the resolver's
+ * own container first, then at the root. That is convenient, and ambiguous when
+ * both hold the name: the container wins, silently. An ARRAY is an absolute
+ * path from the root (`["input", "owner"]`), matching the engine's own path
+ * representation, so it says exactly which value is meant, and it also reaches
+ * a field inside another parameter that no bare name can name.
+ *
+ * An index in a path is LITERAL. `["filters", 0, "operator"]` names the first
+ * item and no other, so it cannot address the array item currently being
+ * walked. A requirement inside an array item names its sibling with a bare
+ * name, which resolves against the item.
+ *
+ * A dotted string is NOT a path: the engine looks the whole string up as one
+ * key, so `"input.owner"` silently never matches. Use the array form.
+ */
+type ResolverRequirement = string | readonly [string | number, ...(string | number)[]];
 /** Shared gates for resolvers that resolve a value: the attachment plumbing
  * plus the param-dataflow prerequisite. (`info` skips these.) */
 interface ResolverBase extends MethodAttachment {
-    /** Sibling parameters that must resolve before this resolver runs (it reads
-     * their values from `input`). The param-dataflow prerequisite, distinct from
-     * `imports`' SDK-capability graph. */
-    requireParameters?: readonly string[];
+    /** Parameters that must resolve before this resolver runs (it reads their
+     * values from `input`). The param-dataflow prerequisite, distinct from
+     * `imports`' SDK-capability graph. See {@link ResolverRequirement} for the
+     * bare-name vs absolute-path forms. */
+    requireParameters?: readonly ResolverRequirement[];
 }
 /** List candidate items and prompt the user to pick one. */
 interface DynamicResolver extends ResolverBase {
@@ -999,10 +1134,10 @@ interface BoundField {
 }
 /** Fields shared by every bound resolver kind. */
 interface BoundResolverBase {
-    /** Sibling parameters that must resolve before this resolver runs (it reads
-     * their values from `input`). The param-dataflow prerequisite, distinct from
-     * `imports`' SDK-capability graph. */
-    requireParameters?: readonly string[];
+    /** Parameters that must resolve before this resolver runs (it reads their
+     * values from `input`). The param-dataflow prerequisite, distinct from
+     * `imports`' SDK-capability graph. See {@link ResolverRequirement}. */
+    requireParameters?: readonly ResolverRequirement[];
 }
 /** Free-text input, no candidate list. */
 interface BoundStaticResolver extends BoundResolverBase {
@@ -1124,7 +1259,19 @@ interface BoundFormatter<TItem = unknown, TInput = Record<string, unknown>, TCon
  * `run` is loosely typed for `imports` (the precise type lives on the
  * `defineMethod` authoring surface, like the shipped definePlugin).
  */
-interface MethodPlugin<TName extends string = string, TInput = unknown, TOutput = unknown, TPositional extends readonly string[] = readonly []> {
+interface MethodPlugin<TName extends string = string, TInput = unknown, TOutput = unknown, TPositional extends readonly string[] = readonly [], 
+/**
+ * What `run` receives, when that differs from what a CALLER may pass.
+ *
+ * They part company for item and list, whose call type mixes in
+ * {@link CallOutputOptions} and {@link PaginatedCallInput}. Those are the
+ * framework's, peeled off before `run`, so folding them into one parameter
+ * told a consumer reading `Parameters<typeof plugin.run>[0]` that `run` gets
+ * a flag the runtime always removes.
+ *
+ * Defaults to `TInput`, since raw's caller and `run` see the same object.
+ */
+TRunInput = TInput> {
     pluginType: "method";
     name: TName;
     namespace?: string;
@@ -1184,7 +1331,15 @@ interface MethodPlugin<TName extends string = string, TInput = unknown, TOutput
      * telemetry fields knowable before the method's own work; never passed to
      * `run`. */
     annotator?: MethodAnnotator;
-    run: (bag: MethodRunBag<any, TInput, any>) => TOutput;
+    /**
+     * Phantom, never present at runtime. `TInput` types the CALL and `TRunInput`
+     * types `run`, and once they differ `run` alone cannot tell a reader which is
+     * which: an interface is structural, so a parameter that appears nowhere in
+     * the body is not inferable. `ExportSurface` recovers the call type from
+     * here. Optional and `undefined`-valued, so no implementation writes it.
+     */
+    readonly __callInput?: TInput;
+    run: (bag: MethodRunBag<any, TRunInput, any>) => TOutput;
     /** How `run`'s result is shaped into the public surface (see Output in the
      * design doc). Omitted is "raw". Stored loosely; the precise per-mode typing
      * lives on the `defineMethod` overloads. */
@@ -1202,9 +1357,21 @@ interface MethodPlugin<TName extends string = string, TInput = unknown, TOutput
      * @internal
      */
     readonly [POSITIONAL_NAMES]?: TPositional;
+    /**
+     * Phantom carrier for the CALL input.
+     *
+     * `TInput` and `TRunInput` differ for item and list, and `run` types the
+     * latter. An interface is structural, so a parameter appearing nowhere in the
+     * body is not inferable, and without this `ExportSurface` would recover the
+     * run input and offer callers the wrong shape. Never present at runtime.
+     * @internal
+     */
+    readonly [CALL_INPUT]?: TInput;
 }
 /** Phantom-only key (see `MethodPlugin`); never set at runtime. */
 declare const POSITIONAL_NAMES: unique symbol;
+/** Phantom-only key (see `MethodPlugin`); never set at runtime. */
+declare const CALL_INPUT: unique symbol;
 /** A method's output mode: raw passthrough, a `{ data }` item envelope, or a
  * paginated list. */
 type OutputMode = "raw" | "item" | "list";
@@ -1234,6 +1401,25 @@ type PageFetchInput = {
 type PaginatedCallInput = PageFetchInput & {
     maxItems?: number;
 };
+/**
+ * Output controls a method's public caller may pass, the sibling of
+ * {@link PaginatedCallInput}: caller-side only, peeled before `run`, and never
+ * part of a plugin's declared input, so `run` never sees it.
+ *
+ * Item and list only, and raw's absence is a decision rather than a gap: raw
+ * reserves NOTHING in the caller's call object. That object is entirely the
+ * author's, and raw is the mode most likely to forward it verbatim into a
+ * request, so a framework key shadowing a domain one there is the worst version
+ * of a collision the framework should not create. A `skipOutputDataValidation`
+ * passed to a raw method is domain input that happens to share the name: not
+ * read, not stripped, and it does not skip.
+ *
+ * Raw still validates. The author's `skipOutputValidation` field is the only
+ * opt-out it honors, which is why that field keeps its name across every mode.
+ */
+type CallOutputOptions = {
+    skipOutputDataValidation?: boolean;
+};
 /**
  * A response whose only own keys are `data` / `nextCursor`. Gates the
  * list-standard overload: a raw envelope with extra keys is not a `StrictPage`
@@ -1263,10 +1449,10 @@ type DataOf<TResponse> = TResponse extends {
 } ? TData : never;
 /**
  * A leaf plugin that is a single value (not a function). `value` is a static
- * constant; `get({ imports })` computes the value from imports. Like a
- * method's `setup`, `get` runs eagerly at createSdk (dependencies first), so a
- * module-level value is built on import. An imported/surfaced property yields
- * the value, not a callable.
+ * constant; `get({ imports, state })` computes the value from imports and
+ * `setup` state, re-running live on each read. An optional `setup` runs once
+ * eagerly at createSdk (dependencies first, like a method's `setup`) to build
+ * that state. An imported/surfaced property yields the value, not a callable.
  */
 interface PropertyPlugin<TName extends string = string, TValue = unknown> {
     pluginType: "property";
@@ -1306,6 +1492,7 @@ interface PropertyPlugin<TName extends string = string, TValue = unknown> {
     get?: (bag: {
         imports: Record<string, unknown>;
         state: unknown;
+        callContext?: CallContext;
     }) => TValue;
     /** Descriptive metadata for the registry / CLI / MCP / docs (carry-only). */
     meta?: LeafMeta;
@@ -1548,7 +1735,10 @@ interface PropertyEntry {
     pluginType: "property";
     name: string;
     value?: any;
-    getValue?: () => any;
+    /** Re-derives the value per read. Receives the live per-call `CallContext`
+     * when installed on a method's `imports` bag with a threaded context, and
+     * nothing on a surface / build-time read. */
+    getValue?: (callContext?: CallContext) => any;
     /** Carried from the descriptor for the registry / CLI / MCP / docs. */
     meta?: LeafMeta;
     /** Carried from the descriptor: templated registry members for this
@@ -1635,14 +1825,24 @@ type PluginSurface<P extends AnyPlugin> = P extends MethodPlugin<infer TName, in
     [K in keyof TExports]: ExportSurface<TExports[K]>;
 } : never;
 /**
- * The framework-owned access an SDK carries beyond its string surface: the
- * legacy `context` string key (back-compat, narrows away later). The off-surface
- * `[CONTEXT]` symbol is attached at runtime (reach it via `getContext`) but kept
- * out of this type so it never leaks into a consumer's emitted declarations.
+ * The framework-owned access an SDK carries beyond its string surface.
+ *
+ * Both keys, because the value has both. `[CONTEXT]` is what materialization
+ * writes and what `getContext` reads, so declaring it is the type telling the
+ * truth. `context` is the legacy string key, kept for back-compat and narrowing
+ * away later.
+ *
+ * The symbol used to be omitted so it would not reach a consumer's emitted
+ * declarations. It is exported from the package root, so it is nameable there,
+ * and hiding it cost more than it saved: `ControllerSdk` had to check the
+ * legacy string key as a stand-in for the real one.
  */
+interface SdkContextCarrier {
+    readonly [CONTEXT]: SdkContext;
+}
 type SdkInternals = {
     context: SdkContext;
-};
+} & SdkContextCarrier;
 /**
  * The materialized SDK for a leaf root: the root's callable (method) or value
  * (property) under its name, plus framework access.
@@ -1685,6 +1885,25 @@ interface PluginSummary<TRequires extends string = never, TProvides extends stri
     /** Ids the plugin and its subgraph provide. @internal */
     readonly [PROVIDES]?: TProvides;
 }
+/**
+ * The id a stand-in declares, carried separately from the requires ledger.
+ *
+ * `declareProperty` requires its own id, so the ledger alone would do. A
+ * `declareOptionalProperty` requires NOTHING, which is the point of it, so its
+ * ledger is empty and the id has nowhere else to live. Reading the id off the
+ * ledger meant an optional stand-in handed a by-reference provider `never`,
+ * and a `never` in that position stopped `CompletenessOf` reporting anything
+ * for the whole graph.
+ *
+ * A carrier of its own keeps the two facts apart: what a stand-in NEEDS, and
+ * what it NAMES.
+ */
+interface StandInId<TId extends string = never> {
+    /** @internal */
+    readonly [DECLARES]?: TId;
+}
+/** Phantom-only key (see `StandInId`); never set at runtime. */
+declare const DECLARES: unique symbol;
 /** The declaration ids a plugin still needs (reads the phantom carrier). */
 type RequiresOf<P> = P extends {
     readonly [REQUIRES]?: infer R;
@@ -2330,6 +2549,26 @@ declare function createPluginStack<TRequires = object>(): PluginStack<TRequires,
     };
 }>;
 
+/**
+ * Reject a LIST stand-in from the ref form, at the REF rather than at `run`.
+ * Without this the mismatch surfaces as a run-return type error, which sends
+ * the reader to the wrong file. The key is the message: a missing required
+ * property names itself in the error.
+ *
+ * A `PaginatedSdkResult` is a decorated thenable the framework builds, so no
+ * hand-written `run` returns one. That makes it a fact about the ref, not a
+ * guess.
+ *
+ * ITEM is deliberately absent. An item surface is `Promise<{ data }>`, which is
+ * also just an ordinary async method returning an object with a `data` field,
+ * and rejecting the second to catch the first turned a valid raw provider into
+ * a compile error with advice that did not apply. An item stand-in implemented
+ * by reference now fails on the run return instead, which is a worse message
+ * for a real mistake but does not refuse correct code.
+ */
+type RefFormRawOnly<TOutput> = TOutput extends PaginatedSdkResult<unknown> ? {
+    "defineMethod(ref, config) provides raw output only; define a list provider from scratch": never;
+} : unknown;
 /**
  * Define a method leaf. The plugin IS the function; `createSdk` (or a
  * dependent's `imports`) binds it under its bare `name`. `imports` is typed
@@ -2389,10 +2628,10 @@ declare function defineMethod<const TName extends string, TInput, TResponse exte
         input?: unknown;
     }) => void | Promise<void>;
     run: (bag: MethodRunBag<ImportsOf<TImports>, TInput, TState>) => TResponse | Promise<TResponse>;
-} & LeafMetaFields): MethodPlugin<TName, TInput, Promise<{
+} & LeafMetaFields): MethodPlugin<TName, TInput & CallOutputOptions, Promise<{
     data: TData;
     meta?: ResponseMeta;
-}>> & LeafSummary<TNamespace, TName, TImports>;
+}>, readonly [], ItemRunInput<TInput>> & LeafSummary<TNamespace, TName, TImports>;
 declare function defineMethod<const TName extends string, TInput, TResponse extends StrictPage$1<TResponse>, TItem = ItemOf$1<TResponse>, const TImports extends ImportsInput = readonly [], const TNamespace extends string = "", TState = undefined>(config: {
     name: TName;
     namespace?: TNamespace;
@@ -2415,7 +2654,7 @@ declare function defineMethod<const TName extends string, TInput, TResponse exte
         input?: unknown;
     }) => void | Promise<void>;
     run: (bag: MethodRunBag<ImportsOf<TImports>, TInput & PageFetchInput, TState>) => TResponse | Promise<TResponse>;
-} & LeafMetaFields): MethodPlugin<TName, TInput & PaginatedCallInput, PaginatedSdkResult<TItem>> & LeafSummary<TNamespace, TName, TImports>;
+} & LeafMetaFields): MethodPlugin<TName, TInput & PaginatedCallInput & CallOutputOptions, PaginatedSdkResult<TItem>, readonly [], ListRunInput<TInput>> & LeafSummary<TNamespace, TName, TImports>;
 declare function defineMethod<const TName extends string, TInput, TResponse, TItem, const TImports extends ImportsInput = readonly [], const TNamespace extends string = "", TState = undefined>(config: {
     name: TName;
     namespace?: TNamespace;
@@ -2438,25 +2677,57 @@ declare function defineMethod<const TName extends string, TInput, TResponse, TIt
         input?: unknown;
     }) => void | Promise<void>;
     run: (bag: MethodRunBag<ImportsOf<TImports>, TInput & PageFetchInput, TState>) => TResponse | Promise<TResponse>;
-} & LeafMetaFields): MethodPlugin<TName, TInput & PaginatedCallInput, PaginatedSdkResult<TItem>> & LeafSummary<TNamespace, TName, TImports>;
-/**
- * Define a method override: a meta-only patch over an already-defined method.
- * Give it the `target` method's id (its bare name if namespace-less) and any of
- * the public {@link LeafMetaFields} (`deprecation`, `packages`, `description`,
- * `categories`, `confirm`, ...); after the SDK materializes, those fields merge
- * onto the target method's entry so the registry / CLI / MCP / docs project the
- * patched values. The target's `run` and resolvers are untouched.
- *
- * Use it for surface-specific tweaks a base method should not carry (e.g. a CLI
- * that deprecates `fetch` while the SDK does not). It fails loud at build if the
- * target does not resolve to a method. Include the override in an aggregate's
+} & LeafMetaFields): MethodPlugin<TName, TInput & PaginatedCallInput & CallOutputOptions, PaginatedSdkResult<TItem>, readonly [], ListRunInput<TInput>> & LeafSummary<TNamespace, TName, TImports>;
+declare function defineMethod<const TName extends string, TInput, TOutput, const TId extends string, const TImports extends ImportsInput = readonly [], TState = undefined>(ref: MethodPlugin<TName, TInput, TOutput> & StandInId<TId> & RefFormRawOnly<TOutput>, config: {
+    imports?: TImports & StaticList<TImports>;
+    inputSchema?: z.ZodType<TInput>;
+    skipInputValidation?: boolean;
+    resolvers?: Record<string, Resolver>;
+    formatter?: Formatter;
+    setup?: (bag: {
+        imports: ImportsOf<TImports>;
+    }) => TState;
+    dispose?: (bag: {
+        imports: ImportsOf<TImports>;
+        state: TState;
+        input?: unknown;
+    }) => void | Promise<void>;
+    run: (bag: MethodRunBag<ImportsOf<TImports>, NoInfer<TInput>, TState>) => NoInfer<TOutput>;
+} & LeafMetaFields): MethodPlugin<TName, TInput, TOutput> & PluginSummary<LeafRequires<TId, TImports>, LeafProvides<TId, TImports>>;
+/**
+ * Patch how a surface PRESENTS an already-defined method, by reference. Pass
+ * the method (or its `declareMethod` stand-in) and any of
+ * {@link OverridableMetaFields}. After the SDK materializes, those fields merge
+ * onto the target's entry, so the registry / CLI / MCP / docs project the
+ * patched values. The target's `run`, resolvers, and declared type are
+ * untouched, which is the whole point: see {@link OverridableMetaFields} for
+ * the fields that are refused and why.
+ *
+ * Use it for a tweak one surface wants and the base method should not carry, a
+ * CLI deprecating `fetch` while the SDK does not. Include it in an aggregate's
  * `imports` to apply it during `createSdk`, or `addPlugin(sdk, override)` to
  * apply it to a built SDK.
+ *
+ * Taking the reference rather than an id string is the same choice
+ * `defineMethod(ref, ...)` and `defineProperty(ref, ...)` make. No id is
+ * respelled, so a rename cannot leave a silent no-op behind, and the name does
+ * not restate what the reference already says. `declareMethod` gives you a
+ * stand-in when you want to patch a method without importing it.
+ *
+ * `namespace` names the OVERRIDE, not the target, so two surfaces can each
+ * patch the same method in one graph without colliding.
+ */
+declare function defineOverride(ref: AnyMethodPlugin, config?: {
+    namespace?: string;
+} & OverridableMetaFields): MethodOverridePlugin;
+/**
+ * @deprecated Use {@link defineOverride}, which takes the method itself instead
+ * of its id spelled out again.
  */
 declare function defineMethodOverride<const TTarget extends string>(config: {
     target: TTarget;
     namespace?: string;
-} & LeafMetaFields): MethodOverridePlugin;
+} & OverridableMetaFields): MethodOverridePlugin;
 /**
  * Define an input resolver: a method attachment for one of its parameters. Like
  * `defineMethod` it declares its own `imports`, and its callbacks receive a
@@ -2477,7 +2748,7 @@ declare function defineMethodOverride<const TTarget extends string>(config: {
 declare function defineResolver<const TImports extends ImportsInput = readonly [], TItem = unknown, TInput = Record<string, unknown>, TContext = unknown>(config: {
     type?: "dynamic";
     imports?: TImports & StaticList<TImports>;
-    requireParameters?: readonly string[];
+    requireParameters?: readonly ResolverRequirement[];
     inputType?: "text" | "password" | "email" | "search";
     placeholder?: string;
     /** Compute side-context once, before `listItems` (pre-fetch, no items yet),
@@ -2539,14 +2810,14 @@ declare function defineResolver<const TImports extends ImportsInput = readonly [
 }): DynamicResolver;
 declare function defineResolver(config: {
     type: "static";
-    requireParameters?: readonly string[];
+    requireParameters?: readonly ResolverRequirement[];
     inputType?: "text" | "password" | "email" | "search";
     placeholder?: string;
 }): StaticResolver;
 declare function defineResolver(config: {
     type: "constant";
     value: unknown;
-    requireParameters?: readonly string[];
+    requireParameters?: readonly ResolverRequirement[];
 }): ConstantResolver;
 declare function defineResolver(config: {
     type: "info";
@@ -2555,7 +2826,7 @@ declare function defineResolver(config: {
 declare function defineResolver<const TImports extends ImportsInput = readonly [], TInput = Record<string, unknown>>(config: {
     type: "object";
     imports?: TImports & StaticList<TImports>;
-    requireParameters?: readonly string[];
+    requireParameters?: readonly ResolverRequirement[];
     properties?: Record<string, Field>;
     /** Build the property map when the key set is dynamic (re-invoked as `input`
      * grow). Returns the map raw, no envelope. */
@@ -2569,7 +2840,7 @@ declare function defineResolver<const TImports extends ImportsInput = readonly [
 }): ObjectResolver;
 declare function defineResolver(config: {
     type: "array";
-    requireParameters?: readonly string[];
+    requireParameters?: readonly ResolverRequirement[];
     items: Resolver | ResolverRef;
     minItems?: number;
     maxItems?: number;
@@ -2612,7 +2883,7 @@ declare function defineFormatter<const TImports extends ImportsInput = readonly
  */
 declare function declareMethod<const TId extends string, TInput = unknown, TOutput = unknown>(config: {
     id: LiteralString<TId>;
-}): MethodPlugin<LastSegment<TId>, TInput, TOutput> & PluginSummary<TId, never>;
+}): MethodPlugin<LastSegment<TId>, TInput, TOutput> & PluginSummary<TId, never> & StandInId<TId>;
 /**
  * Declare an OPTIONAL stand-in for a method registered elsewhere: the method twin
  * of `declareOptionalProperty`. Unlike `declareMethod`, an unsatisfied optional
@@ -2625,11 +2896,13 @@ declare function declareOptionalMethod<const TId extends string, TInput = unknow
     id: LiteralString<TId>;
 }): MethodPlugin<LastSegment<TId>, TInput, TOutput> & {
     optional: true;
-} & PluginSummary<never, never>;
+} & PluginSummary<never, never> & StandInId<TId>;
 /**
- * Define a property leaf. Either a static `value` or a computed `get` (eager,
- * dependencies first, like `setup`). `createSdk`, a dependent's `imports`, or
- * an aggregate's re-export binds it under its bare `name` and yields the value.
+ * Define a property leaf. Either a static `value` or a computed `get`, which
+ * re-runs live on each read; an optional `setup` runs once at `createSdk`
+ * (dependencies first, like a method's `setup`) to build the state `get` reads.
+ * `createSdk`, a dependent's `imports`, or an aggregate's re-export binds it
+ * under its bare `name` and yields the value.
  */
 declare function defineProperty<const TName extends string, TValue, const TNamespace extends string = "">(config: {
     name: TName;
@@ -2651,11 +2924,29 @@ declare function defineProperty<const TName extends string, TValue, const TImpor
     get: (bag: {
         imports: ImportsOf<TImports>;
         state: TState;
+        /** The live per-call context when the property is read from a method's
+         * `imports` bag — every method call has one, at any depth. Undefined only
+         * where no call is in flight: the property bound onto the SDK object
+         * itself, and reads from a `setup`-time imports bag. A context-aware
+         * property reads its `callId` off this; because its value is then specific
+         * to the reading call, callers must not cache it across calls. */
+        callContext?: CallContext;
     }) => TValue;
     /** Templated registry members for this property's dynamic sub-surface (e.g.
      * a proxy): each a bodyless declaration keyed by `path` instead of `name`. */
     dynamicMembers?: readonly DynamicMember[];
 } & LeafMetaFields): PropertyPlugin<TName, TValue> & LeafSummary<TNamespace, TName, TImports>;
+/**
+ * Provide a value for a declared property BY REFERENCE: pass the
+ * `declareProperty` / `declareOptionalProperty` stand-in instead of respelling
+ * its `name` / `namespace`, and `value` is typed against the declaration. The
+ * result is a real property that satisfies the stand-in (or overrides its
+ * default) by id. The refactor-safe, no-string alternative to matching ids by
+ * hand (and the in-graph replacement for `createSdk`'s `configuration` channel).
+ */
+declare function defineProperty<const TName extends string, TValue, const TId extends string>(ref: PropertyPlugin<TName, TValue> & StandInId<TId>, config: {
+    value: NoInfer<TValue>;
+} & LeafMetaFields): PropertyPlugin<TName, TValue> & PluginSummary<never, TId>;
 /**
  * Declare a stand-in for a property registered elsewhere (a configured factory
  * plugin, e.g. the api client built from options). Carries only a name and a
@@ -2666,7 +2957,7 @@ declare function defineProperty<const TName extends string, TValue, const TImpor
  */
 declare function declareProperty<const TId extends string, TValue = unknown>(config: {
     id: LiteralString<TId>;
-}): PropertyPlugin<LastSegment<TId>, TValue> & PluginSummary<TId, never>;
+}): PropertyPlugin<LastSegment<TId>, TValue> & PluginSummary<TId, never> & StandInId<TId>;
 /**
  * Declare an OPTIONAL stand-in for a property registered elsewhere. Unlike
  * `declareProperty`, a `declareOptionalProperty` left unsatisfied is NOT a missing
@@ -2682,7 +2973,7 @@ declare function declareProperty<const TId extends string, TValue = unknown>(con
  */
 declare function declareOptionalProperty<const TId extends string, TValue = unknown>(config: {
     id: LiteralString<TId>;
-}): PropertyPlugin<LastSegment<TId>, TValue | undefined> & PluginSummary<never, never>;
+}): PropertyPlugin<LastSegment<TId>, TValue | undefined> & PluginSummary<never, never> & StandInId<TId>;
 /**
  * Declare a DEFAULT provider for a dependency you own: import the capability the
  * given plugin provides, and fall back to that plugin when nothing else provides
@@ -3072,7 +3363,7 @@ interface CoreOptions {
     logStabilityNotice?: (notice: StabilityNotice) => void;
     /**
      * Report what output validation stripped, on the response's
-     * `meta.outputValidation.droppedPaths` (the name mirrors that path). Off by
+     * `meta.outputDataValidation.droppedPaths`. Off by
      * default: the report is a debugging aid for reconciling a schema against the
      * wire, and a sidecar every caller has to ignore is worse than one a head
      * turns on while it audits its schemas. Off also skips the recursive
@@ -3088,7 +3379,7 @@ interface CoreOptions {
  * `CoreOptions | undefined` (absent means kitcore's built-in behavior). Heads
  * supply the value via `createSdk`'s `configuration` or a registered property.
  */
-declare const coreOptionsPluginRef: PropertyPlugin<"coreOptions", CoreOptions | undefined> & PluginSummary<never, never>;
+declare const coreOptionsPluginRef: PropertyPlugin<"coreOptions", CoreOptions | undefined> & PluginSummary<never, never> & StandInId<"kitcore/coreOptions">;
 /**
  * Escape hatch. A built-in privileged plugin whose value is the live
  * `SdkContext` (the raw plugin graph). Importing it (`imports.context`) lets a
@@ -3102,34 +3393,32 @@ declare const coreOptionsPluginRef: PropertyPlugin<"coreOptions", CoreOptions |
  */
 declare const dangerousContextPlugin: PropertyPlugin<"context", SdkContext>;
 /**
- * A built-in that reports the live SDK surface as the canonical
+ * A built-in that reports the SDK surface as the canonical
  * {@link RegistryResult}. It is just a method depending on `dangerousContextPlugin` (no
- * new privilege): re-export it to put `getRegistry()` on the SDK surface. Reads
- * `context.surface` at call time, so it reflects any post-seal `addPlugin`
- * additions, and produces the same registry shape the heads (CLI / MCP / docs)
- * consume.
+ * new privilege): re-export it to put `getRegistry()` on the SDK surface. A thin
+ * shim over the shared `getCachedRegistry`, the same path the free
+ * `getRegistry(sdk)` takes, so a surfaced call and an off-surface call return
+ * the identical memoized object. Surfacing is optional, since controllers reach
+ * the registry through `getRegistry(sdk)` whether or not a head re-exports this.
  */
 declare const getRegistryPlugin: MethodPlugin<"getRegistry", {
     package?: string | undefined;
-} | undefined, RegistryResult, readonly []> & LeafSummary<"kitcore", "getRegistry", readonly [PropertyPlugin<"context", SdkContext>]>;
+} | undefined, RegistryResult, readonly [], {
+    package?: string | undefined;
+} | undefined> & LeafSummary<"kitcore", "getRegistry", readonly [PropertyPlugin<"context", SdkContext>]>;
 
-/**
- * The external escape-hatch key for an SDK's context. A Symbol,
- * not a string, so it stays off the string surface (which is exactly the root's
- * exports) and is collision-free and clearly internal. It is attached at
- * runtime but kept OUT of the public SDK type (a `unique symbol` in an exported
- * type can't be named in a consumer's emitted `.d.ts`); reach it through the
- * typed `getContext(sdk)` accessor.
- *
- * `Symbol.for`, not `Symbol()`: heads bundle kitcore (tsup `noExternal`), so
- * an sdk built by one bundle's copy must still be readable by another copy's
- * `getContext` / `resolvePlugin` (e.g. a CLI sdk inspected with helpers
- * imported from `@zapier/zapier-sdk`). The global symbol registry makes every
- * copy agree on the key.
- */
-declare const CONTEXT: unique symbol;
 /** The off-surface escape hatch to an SDK's `SdkContext`. */
 declare function getContext(sdk: unknown): SdkContext;
+/**
+ * Read an SDK's registry from outside its surface, so a head need not re-export
+ * `getRegistryPlugin` for a controller to introspect it. Module-model SDKs go
+ * through the shared, memoized {@link getCachedRegistry} (context-keyed, so this
+ * and a surfaced `getRegistry()` return the same object). A pure-legacy
+ * stack-built SDK has no `[CONTEXT]` graph; for those the only path is a
+ * surfaced `getRegistry()`, so fall back to it when present. Each package
+ * filter is memoized separately.
+ */
+declare function getRegistry(sdk: unknown, packageFilter?: string): RegistryResult;
 /**
  * Resolve a plugin's materialized value against a built SDK: a method's
  * callable or a property's value (the same thing an importer receives), NOT
@@ -3480,10 +3769,12 @@ interface ControllerParameterDescription {
     /** Statically known labeled values, when the parameter is a fixed enum. Richer
      * than `schema.enum` (carries label/hint), so kept alongside `schema`. */
     choices?: ControllerChoice[];
-    /** Sibling parameters this one depends on (`requireParameters`). A form host
-     * reads this to know which fields are independent (render together) and which
-     * to re-fetch when a dependency changes. */
-    requireParameters?: readonly string[];
+    /** Parameters this one depends on (`requireParameters`). A form host reads
+     * this to know which fields are independent (render together) and which to
+     * re-fetch when a dependency changes. A bare name is resolved by the engine
+     * (container, then root); an array is an absolute path. Both are plain JSON,
+     * so this stays serializable across the controller wall. */
+    requireParameters?: readonly (string | readonly (string | number)[])[];
 }
 /** A method's lightweight index entry: enough to render a menu or tool list
  * without the full per-parameter detail. The list face of {@link Controller}. */
@@ -3576,20 +3867,82 @@ interface Controller {
     }>;
 }
 
-/** The slice of a built SDK the driver needs: its registry accessor. */
-interface ControllerSdk {
+/**
+ * What the driver needs of a built SDK: one of two ways to reach a registry.
+ *
+ * The registry is read with the free {@link getRegistry}, which finds it on the
+ * SDK's context and falls back to a surfaced `getRegistry()` for a legacy
+ * stack-built SDK. So demanding the surfaced method alone is wrong: a bare tool
+ * SDK does not surface one, and it cannot always add `getRegistryPlugin`
+ * either, because a head bundling its own kitcore copy would collide with it on
+ * the shared `kitcore/getRegistry` id.
+ *
+ * A union, because those really are two different shapes. `SdkInternals` is
+ * what every `createSdk` result carries, and the structural branch is the
+ * legacy one. Anything else can never back a controller, and saying so here
+ * beats an internal registry error on the caller's first `listMethods()`.
+ *
+ * The context branch is `SdkInternals`, which declares the `[CONTEXT]` symbol
+ * materialization actually writes. So this checks the real thing rather than a
+ * correlated one.
+ */
+type ControllerSdk = SdkInternals | {
     getRegistry: (options?: {
         package?: string;
     }) => RegistryResult;
-}
+};
 /**
- * Build a {@link Controller} over a built SDK. Reads `sdk.getRegistry()`
+ * Build a {@link Controller} over a built SDK. Reads the registry
  * at call time (so post-build `addPlugin` additions are visible) to find each
  * method's canonical input schema and bound resolvers, then drives the engine.
  * The SDK surface itself is untouched; this is a sibling layer.
  */
 declare function createController(sdk: ControllerSdk): Controller;
 
+/**
+ * The floor the framework holds its own call parameters to, and the only
+ * statement of their shapes. Which of them a given boundary reads at all is
+ * that boundary's {@link FrameworkOptionsPolicy}.
+ *
+ * MINIMAL on purpose. It rejects what the machinery cannot act on and nothing
+ * else, leaving a plugin free to tighten it. `pageSize` is at least 1 because a
+ * page loop asking upstream for zero items does not terminate. `maxItems` may
+ * be 0, since "return nothing" is a coherent request the loop already handles.
+ * `cursor` is any string: its meaning belongs to the head's API, including
+ * whatever a reverse-paginating one encodes in it.
+ *
+ * A plugin that wants a tighter rule writes it in its own `inputSchema`, and
+ * both run. See {@link parseCallOptions}.
+ */
+declare const CallFrameworkOptionsSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    skipOutputDataValidation: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type CallFrameworkOptions = z.infer<typeof CallFrameworkOptionsSchema>;
+type CallFrameworkOptionKey = keyof CallFrameworkOptions;
+/**
+ * What one boundary does with the framework's call parameters.
+ *
+ * There is no global answer, because the modes differ. A list call feeds a page
+ * loop; an item call has no loop to feed; a legacy handler honors nothing the
+ * framework added after it was written.
+ *
+ * This is a fact about the MODE, decided when the boundary is built. It says
+ * nothing about the plugin's schema, which is the difference between this and
+ * everything {@link parseCallOptions} used to infer.
+ */
+interface FrameworkOptionsPolicy {
+    /** The parameters this boundary reads. Each is also held to
+     * {@link CallFrameworkOptionsSchema}, whatever the plugin's schema says. */
+    claims: readonly CallFrameworkOptionKey[];
+    /** The subset handed to `run` even when the plugin's schema dropped it,
+     * because `run` cannot do its job without it. A list `run` is asked for one
+     * page, so it gets that page. */
+    injects: readonly CallFrameworkOptionKey[];
+}
+
 /**
  * Generic utility functions for creating SDK-method wrappers.
  *
@@ -3631,6 +3984,11 @@ declare function createFunction<TOptions, TResult, TSchemaOptions extends TOptio
      * onMethodStart with the normalized input, its result merged into the
      * call's annotation bag. */
     annotator?: (input: unknown) => Annotations;
+    /** Which framework call parameters this callable reads; see
+     * `FrameworkOptionsPolicy`. Omitted means none, which is what a legacy
+     * handler wants: nothing there honors a framework parameter, so every key
+     * in the call object is the handler's own. */
+    frameworkOptions?: FrameworkOptionsPolicy;
     /** Live read of the method's deprecation meta (see signalDeprecation). */
     getDeprecation?: () => FunctionDeprecation | undefined;
     /** Live read of the method's stability level (see signalStability). */
@@ -3671,8 +4029,12 @@ declare function createPaginatedFunction<TUserOptions, TResponse, TItem = ItemTy
     adaptPage?: (response: TResponse) => SdkPage<NoInfer<TItem>>;
     /** Pre-run per-method annotator (see applyAnnotations). */
     annotator?: (input: unknown) => Annotations;
-    /** Applied to each canonical page after the shape guard (output validation). */
-    finalizePage?: (page: SdkPage<TItem>) => SdkPage<TItem>;
+    /** Applied to each canonical page after the shape guard (output validation),
+     * with this call's options so it can read per-call controls. */
+    finalizePage?: (page: SdkPage<TItem>, callOptions: unknown) => SdkPage<TItem>;
+    /** Which framework call parameters this callable reads; see
+     * `FrameworkOptionsPolicy`. */
+    frameworkOptions?: FrameworkOptionsPolicy;
     /** Live read of the method's deprecation meta (see signalDeprecation). */
     getDeprecation?: () => FunctionDeprecation | undefined;
     /** Live read of the method's stability level (see signalStability). */
@@ -4157,14 +4519,14 @@ type SendHttpRequest = (request: HttpRequest) => ReturnType<typeof fetch>;
  * removes the only boundary below `initializeHttpRequest`, and a retry wrap
  * would then re-initialize and mint a fresh `operationId` per attempt.
  */
-declare const attemptHttpRequestPlugin: MethodPlugin<"attemptHttpRequest", AttemptHttpRequestInput, Promise<Response>, readonly []> & LeafSummary<"kitcore", "attemptHttpRequest", readonly [MethodPlugin<"prepareHttpRequest", PrepareHttpRequestInput, Promise<HttpRequest>, readonly []> & LeafSummary<"kitcore", "prepareHttpRequest", readonly []>, MethodPlugin<"authorizeHttpRequest", AuthorizeHttpRequestInput, Promise<HttpRequest>, readonly []> & LeafSummary<"kitcore", "authorizeHttpRequest", readonly []>, MethodPlugin<"dispatchHttpRequest", DispatchHttpRequestInput, Promise<Response>, readonly []> & LeafSummary<"kitcore", "dispatchHttpRequest", readonly []>, MethodPlugin<"receiveHttpResponse", ReceiveHttpResponseInput, Promise<Response>, readonly []> & LeafSummary<"kitcore", "receiveHttpResponse", readonly []>]>;
+declare const attemptHttpRequestPlugin: MethodPlugin<"attemptHttpRequest", AttemptHttpRequestInput, Promise<Response>, readonly [], AttemptHttpRequestInput> & LeafSummary<"kitcore", "attemptHttpRequest", readonly [MethodPlugin<"prepareHttpRequest", PrepareHttpRequestInput, Promise<HttpRequest>, readonly [], PrepareHttpRequestInput> & LeafSummary<"kitcore", "prepareHttpRequest", readonly []>, MethodPlugin<"authorizeHttpRequest", AuthorizeHttpRequestInput, Promise<HttpRequest>, readonly [], AuthorizeHttpRequestInput> & LeafSummary<"kitcore", "authorizeHttpRequest", readonly []>, MethodPlugin<"dispatchHttpRequest", DispatchHttpRequestInput, Promise<Response>, readonly [], DispatchHttpRequestInput> & LeafSummary<"kitcore", "dispatchHttpRequest", readonly []>, MethodPlugin<"receiveHttpResponse", ReceiveHttpResponseInput, Promise<Response>, readonly [], ReceiveHttpResponseInput> & LeafSummary<"kitcore", "receiveHttpResponse", readonly []>]>;
 
 /**
  * Completes the operation context: normalizes the caller's request and records
  * whether its body can be sent again. Everything below this stage reads those
  * two facts off `attempt.operation`, and neither changes across retries.
  */
-declare const initializeHttpRequestPlugin: MethodPlugin<"initializeHttpRequest", InitializeHttpRequestInput, Promise<HttpOperationContext>, readonly []> & LeafSummary<"kitcore", "initializeHttpRequest", readonly []>;
+declare const initializeHttpRequestPlugin: MethodPlugin<"initializeHttpRequest", InitializeHttpRequestInput, Promise<HttpOperationContext>, readonly [], InitializeHttpRequestInput> & LeafSummary<"kitcore", "initializeHttpRequest", readonly []>;
 
 /**
  * Options for {@link retryHttpRequestPlugin}, supplied by id like every other
@@ -4194,7 +4556,7 @@ interface RetryHttpRequestOptions {
     retryOnError?: boolean;
 }
 declare const RETRY_HTTP_REQUEST_OPTIONS_ID = "kitcore/retryHttpRequestOptions";
-declare const retryHttpRequestOptionsPluginRef: PropertyPlugin<"retryHttpRequestOptions", RetryHttpRequestOptions | undefined> & PluginSummary<never, never>;
+declare const retryHttpRequestOptionsPluginRef: PropertyPlugin<"retryHttpRequestOptions", RetryHttpRequestOptions | undefined> & PluginSummary<never, never> & StandInId<"kitcore/retryHttpRequestOptions">;
 /**
  * Re-issue a failed attempt, opt-in by composition.
  *
@@ -4226,13 +4588,13 @@ declare const retryHttpRequestOptionsPluginRef: PropertyPlugin<"retryHttpRequest
  */
 declare const retryHttpRequestPlugin: HookPlugin<string>;
 
-declare const prepareHttpRequestPlugin: MethodPlugin<"prepareHttpRequest", PrepareHttpRequestInput, Promise<HttpRequest>, readonly []> & LeafSummary<"kitcore", "prepareHttpRequest", readonly []>;
+declare const prepareHttpRequestPlugin: MethodPlugin<"prepareHttpRequest", PrepareHttpRequestInput, Promise<HttpRequest>, readonly [], PrepareHttpRequestInput> & LeafSummary<"kitcore", "prepareHttpRequest", readonly []>;
 
-declare const authorizeHttpRequestPlugin: MethodPlugin<"authorizeHttpRequest", AuthorizeHttpRequestInput, Promise<HttpRequest>, readonly []> & LeafSummary<"kitcore", "authorizeHttpRequest", readonly []>;
+declare const authorizeHttpRequestPlugin: MethodPlugin<"authorizeHttpRequest", AuthorizeHttpRequestInput, Promise<HttpRequest>, readonly [], AuthorizeHttpRequestInput> & LeafSummary<"kitcore", "authorizeHttpRequest", readonly []>;
 
-declare const dispatchHttpRequestPlugin: MethodPlugin<"dispatchHttpRequest", DispatchHttpRequestInput, Promise<Response>, readonly []> & LeafSummary<"kitcore", "dispatchHttpRequest", readonly []>;
+declare const dispatchHttpRequestPlugin: MethodPlugin<"dispatchHttpRequest", DispatchHttpRequestInput, Promise<Response>, readonly [], DispatchHttpRequestInput> & LeafSummary<"kitcore", "dispatchHttpRequest", readonly []>;
 
-declare const receiveHttpResponsePlugin: MethodPlugin<"receiveHttpResponse", ReceiveHttpResponseInput, Promise<Response>, readonly []> & LeafSummary<"kitcore", "receiveHttpResponse", readonly []>;
+declare const receiveHttpResponsePlugin: MethodPlugin<"receiveHttpResponse", ReceiveHttpResponseInput, Promise<Response>, readonly [], ReceiveHttpResponseInput> & LeafSummary<"kitcore", "receiveHttpResponse", readonly []>;
 
 /**
  * The transport orchestrator: turn an {@link HttpRequestInput} into a native
@@ -4261,7 +4623,7 @@ declare const receiveHttpResponsePlugin: MethodPlugin<"receiveHttpResponse", Rec
  * No retry by default: with nothing composed this runs exactly one attempt.
  * `retryHttpRequestPlugin` is opt-in.
  */
-declare const sendHttpRequestPlugin: MethodPlugin<"sendHttpRequest", HttpRequestInput, Promise<Response>, readonly []> & LeafSummary<"kitcore", "sendHttpRequest", readonly [MethodPlugin<"initializeHttpRequest", InitializeHttpRequestInput, Promise<HttpOperationContext>, readonly []> & LeafSummary<"kitcore", "initializeHttpRequest", readonly []>, MethodPlugin<"attemptHttpRequest", AttemptHttpRequestInput, Promise<Response>, readonly []> & LeafSummary<"kitcore", "attemptHttpRequest", readonly [MethodPlugin<"prepareHttpRequest", PrepareHttpRequestInput, Promise<HttpRequest>, readonly []> & LeafSummary<"kitcore", "prepareHttpRequest", readonly []>, MethodPlugin<"authorizeHttpRequest", AuthorizeHttpRequestInput, Promise<HttpRequest>, readonly []> & LeafSummary<"kitcore", "authorizeHttpRequest", readonly []>, MethodPlugin<"dispatchHttpRequest", DispatchHttpRequestInput, Promise<Response>, readonly []> & LeafSummary<"kitcore", "dispatchHttpRequest", readonly []>, MethodPlugin<"receiveHttpResponse", ReceiveHttpResponseInput, Promise<Response>, readonly []> & LeafSummary<"kitcore", "receiveHttpResponse", readonly []>]>]>;
+declare const sendHttpRequestPlugin: MethodPlugin<"sendHttpRequest", HttpRequestInput, Promise<Response>, readonly [], HttpRequestInput> & LeafSummary<"kitcore", "sendHttpRequest", readonly [MethodPlugin<"initializeHttpRequest", InitializeHttpRequestInput, Promise<HttpOperationContext>, readonly [], InitializeHttpRequestInput> & LeafSummary<"kitcore", "initializeHttpRequest", readonly []>, MethodPlugin<"attemptHttpRequest", AttemptHttpRequestInput, Promise<Response>, readonly [], AttemptHttpRequestInput> & LeafSummary<"kitcore", "attemptHttpRequest", readonly [MethodPlugin<"prepareHttpRequest", PrepareHttpRequestInput, Promise<HttpRequest>, readonly [], PrepareHttpRequestInput> & LeafSummary<"kitcore", "prepareHttpRequest", readonly []>, MethodPlugin<"authorizeHttpRequest", AuthorizeHttpRequestInput, Promise<HttpRequest>, readonly [], AuthorizeHttpRequestInput> & LeafSummary<"kitcore", "authorizeHttpRequest", readonly []>, MethodPlugin<"dispatchHttpRequest", DispatchHttpRequestInput, Promise<Response>, readonly [], DispatchHttpRequestInput> & LeafSummary<"kitcore", "dispatchHttpRequest", readonly []>, MethodPlugin<"receiveHttpResponse", ReceiveHttpResponseInput, Promise<Response>, readonly [], ReceiveHttpResponseInput> & LeafSummary<"kitcore", "receiveHttpResponse", readonly []>]>]>;
 
 /**
  * `fetch` — native `fetch(url, init)` ergonomics over the transport. It
@@ -4287,7 +4649,10 @@ declare const sendHttpRequestPlugin: MethodPlugin<"sendHttpRequest", HttpRequest
 declare const fetchPlugin: MethodPlugin<"fetch", {
     url: string | URL;
     init?: Omit<HttpRequestInput, "url">;
-}, Promise<Response>, readonly ["url", "init"]> & LeafSummary<"kitcore", "fetch", readonly [MethodPlugin<"sendHttpRequest", HttpRequestInput, Promise<Response>, readonly []> & LeafSummary<"kitcore", "sendHttpRequest", readonly [MethodPlugin<"initializeHttpRequest", InitializeHttpRequestInput, Promise<HttpOperationContext>, readonly []> & LeafSummary<"kitcore", "initializeHttpRequest", readonly []>, MethodPlugin<"attemptHttpRequest", AttemptHttpRequestInput, Promise<Response>, readonly []> & LeafSummary<"kitcore", "attemptHttpRequest", readonly [MethodPlugin<"prepareHttpRequest", PrepareHttpRequestInput, Promise<HttpRequest>, readonly []> & LeafSummary<"kitcore", "prepareHttpRequest", readonly []>, MethodPlugin<"authorizeHttpRequest", AuthorizeHttpRequestInput, Promise<HttpRequest>, readonly []> & LeafSummary<"kitcore", "authorizeHttpRequest", readonly []>, MethodPlugin<"dispatchHttpRequest", DispatchHttpRequestInput, Promise<Response>, readonly []> & LeafSummary<"kitcore", "dispatchHttpRequest", readonly []>, MethodPlugin<"receiveHttpResponse", ReceiveHttpResponseInput, Promise<Response>, readonly []> & LeafSummary<"kitcore", "receiveHttpResponse", readonly []>]>]>]>;
+}, Promise<Response>, readonly ["url", "init"], {
+    url: string | URL;
+    init?: Omit<HttpRequestInput, "url">;
+}> & LeafSummary<"kitcore", "fetch", readonly [MethodPlugin<"sendHttpRequest", HttpRequestInput, Promise<Response>, readonly [], HttpRequestInput> & LeafSummary<"kitcore", "sendHttpRequest", readonly [MethodPlugin<"initializeHttpRequest", InitializeHttpRequestInput, Promise<HttpOperationContext>, readonly [], InitializeHttpRequestInput> & LeafSummary<"kitcore", "initializeHttpRequest", readonly []>, MethodPlugin<"attemptHttpRequest", AttemptHttpRequestInput, Promise<Response>, readonly [], AttemptHttpRequestInput> & LeafSummary<"kitcore", "attemptHttpRequest", readonly [MethodPlugin<"prepareHttpRequest", PrepareHttpRequestInput, Promise<HttpRequest>, readonly [], PrepareHttpRequestInput> & LeafSummary<"kitcore", "prepareHttpRequest", readonly []>, MethodPlugin<"authorizeHttpRequest", AuthorizeHttpRequestInput, Promise<HttpRequest>, readonly [], AuthorizeHttpRequestInput> & LeafSummary<"kitcore", "authorizeHttpRequest", readonly []>, MethodPlugin<"dispatchHttpRequest", DispatchHttpRequestInput, Promise<Response>, readonly [], DispatchHttpRequestInput> & LeafSummary<"kitcore", "dispatchHttpRequest", readonly []>, MethodPlugin<"receiveHttpResponse", ReceiveHttpResponseInput, Promise<Response>, readonly [], ReceiveHttpResponseInput> & LeafSummary<"kitcore", "receiveHttpResponse", readonly []>]>]>]>;
 
 /**
  * Headers with every credential value masked, as a plain object a logger can
@@ -4333,9 +4698,9 @@ interface NormalizedConnection {
     value: string;
 }
 
-declare const defaultConnectionSchemePlugin: MethodPlugin<"defaultConnectionScheme", DefaultConnectionSchemeInput, string | undefined, readonly []> & LeafSummary<"kitcore", "defaultConnectionScheme", readonly []>;
+declare const defaultConnectionSchemePlugin: MethodPlugin<"defaultConnectionScheme", DefaultConnectionSchemeInput, string | undefined, readonly [], DefaultConnectionSchemeInput> & LeafSummary<"kitcore", "defaultConnectionScheme", readonly []>;
 
-declare const normalizeConnectionPlugin: MethodPlugin<"normalizeConnection", NormalizeConnectionInput, NormalizedConnection | undefined, readonly []> & LeafSummary<"kitcore", "normalizeConnection", readonly [MethodPlugin<"defaultConnectionScheme", DefaultConnectionSchemeInput, string | undefined, readonly []> & LeafSummary<"kitcore", "defaultConnectionScheme", readonly []>]>;
+declare const normalizeConnectionPlugin: MethodPlugin<"normalizeConnection", NormalizeConnectionInput, NormalizedConnection | undefined, readonly [], NormalizeConnectionInput> & LeafSummary<"kitcore", "normalizeConnection", readonly [MethodPlugin<"defaultConnectionScheme", DefaultConnectionSchemeInput, string | undefined, readonly [], DefaultConnectionSchemeInput> & LeafSummary<"kitcore", "defaultConnectionScheme", readonly []>]>;
 
 /**
  * SELECT which connection REFERENCE a call should use: the explicit one if the
@@ -4353,6 +4718,6 @@ declare const normalizeConnectionPlugin: MethodPlugin<"normalizeConnection", Nor
  * fatal depends on what the caller declared it needs, which this stage cannot
  * see, so this stays policy-free.
  */
-declare const resolveConnectionPlugin: MethodPlugin<"resolveConnection", ResolveConnectionInput, string | undefined, readonly []> & LeafSummary<"kitcore", "resolveConnection", readonly []>;
+declare const resolveConnectionPlugin: MethodPlugin<"resolveConnection", ResolveConnectionInput, string | undefined, readonly [], ResolveConnectionInput> & LeafSummary<"kitcore", "resolveConnection", readonly []>;
 
-export { type AdaptError, type AdaptErrorOptions, type AdaptPage, type AggregatePlugin, type Annotations, type ArrayResolver$1 as ArrayResolver, type AsyncContext, type AttemptHttpRequestInput, type AuthorizeHttpRequestInput, type BoundFormatter, type BoundResolver, CONTEXT, CORE_ERROR_SYMBOL, CORE_OPTIONS_ID, CORE_SIGNAL_SYMBOL, type CallContext, type CallOrigin, type CategoryDefinition, type ComposedAnnotator, type ConstantResolver$1 as ConstantResolver, type Controller, type ControllerAction, type ControllerAffordance, type ControllerAnswerFn, type ControllerChoice, type ControllerError, type ControllerIssue, type ControllerListingPage, type ControllerListingPosition, type ControllerMethodDescription, type ControllerMethodSummary, type ControllerPagination, type ControllerParameterDescription, type ControllerPath, type ControllerQuestion, type ControllerResult, type ControllerSdk, type ControllerSelectPage, type ControllerState, type CoreApiError, CoreCancelledSignal, CoreDisposeError, CoreError, CoreErrorCode, type CoreErrorOptions, type CoreOptions, CoreSignal, type CreateSdkOptions, type DefaultConnectionSchemeInput, type DeprecatedPromptConfigChoice, type DeprecationLogger, type DeprecationWarning, type DispatchHttpRequestInput, type DisposeFn, type DynamicListResolver, type DynamicMember, type DynamicResolver$1 as DynamicResolver, type DynamicSearchResolver, type FieldsResolver, type FormattedItem, type Formatter, type FunctionDeprecation, type FunctionRegistryEntry, type HookAnnotator, type HookPlugin, type HttpAttemptContext, type HttpFetchInit, type HttpOperationContext, type HttpOperationStart, type HttpPipelineState, type HttpRequest, type HttpRequestInput, type HttpResponse, type InitializeHttpRequestInput, type LeafMeta, type LeafSummary, type LegacyMergePlugin, type LegacyPlugin, type ListItemsResult, type ListPromptConfig, type MethodAnnotator, type MethodAttachment, type MethodHooks, type MethodOverridePlugin, type MethodPlugin, type MethodScope, type Resolver as ModelResolver, type NegatableMetadata, type NormalizeConnectionInput, type NormalizedConnection, type OnMethodEnd, type OnMethodEndContext, type OnMethodStart, type OnMethodStartContext, type OutputFormatter, type PaginatedSdkFunction, type PaginatedSdkResult, type Plugin, type PluginMeta, type PluginProvides, type PluginStack, type PluginSummary, type PluginSurface, type PositionalMetadata, type PrepareHttpRequestInput, type PromptConfig, type PromptConfigChoice, type PropertyPlugin, RETRY_HTTP_REQUEST_OPTIONS_ID, type ReceiveHttpResponseInput, type RegistryResult, type RequiredSdkOf, type ResolveConnectionInput, type Resolver$1 as Resolver, type ResolverConfig, type ResolverFieldItem, type ResolverMetadata, type ResolverPromptConfig, type ResolverType, type ResponseMeta, type RetryHttpRequestOptions, STABILITY_LEVELS, STABILITY_TITLES, type Sdk, type SdkContext, type SdkPage, type SendHttpRequest, type StabilityLevel, type StabilityNotice, type StabilityNoticeLogger, type StaticResolver$1 as StaticResolver, type ValidResolvers, addPlugin, applyStabilityLabel, attemptHttpRequestPlugin, authorizeHttpRequestPlugin, canonicalInputSchema, composePlugins, concatLists, concatPaginated, coreOptionsPluginRef, createAsyncContext, createController, createCoreError, createCorePlugin, createDeprecationLogger, createFunction, createPaginatedFunction, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createPrefixedCursor, createSdk, createStabilityNoticeLogger, createValidator, dangerousContextPlugin, declareDefault, declareMethod, declareOptionalMethod, declareOptionalProperty, declarePlugin, declareProperty, decodeIncomingCursor, defaultConnectionSchemePlugin, defaultLogDeprecation, defineFormatter, defineHook, defineLegacyMerge, defineMethod, defineMethodOverride, definePlugin, defineProperty, defineResolver, dispatchHttpRequestPlugin, disposeSdk, fetchPlugin, fromFunctionPlugin, getContext, getCoreErrorCause, getCoreErrorCode, getCurrentDepth, getCurrentScope, getFieldDescriptions, getNegatable, getOutputSchema, getRegistryPlugin, getSchemaDescription, initializeHttpRequestPlugin, isCoreCancelledSignal, isCoreError, isCoreSignal, isNestedMethodCall, isPositional, isTelemetryNested, normalizeConnectionPlugin, normalizeStability, omitExports, openEnum, paginate, paginateBuffered, paginateMaxItems, prepareHttpRequestPlugin, receiveHttpResponsePlugin, redactHeaders, redactHttpRequest, resolveConnectionPlugin, resolvePlugin, retryHttpRequestOptionsPluginRef, retryHttpRequestPlugin, runInMethodScope, runWithTelemetryContext, selectExports, sendHttpRequestPlugin, splitPrefixedCursor, toIterable, toSnakeCase, toTitleCase, validateOptions, withOutputSchema, withPositional, withResolver };
+export { type AdaptError, type AdaptErrorOptions, type AdaptPage, type AggregatePlugin, type Annotations, type ArrayResolver$1 as ArrayResolver, type AsyncContext, type AttemptHttpRequestInput, type AuthorizeHttpRequestInput, type BoundFormatter, type BoundResolver, CONTEXT, CORE_ERROR_SYMBOL, CORE_OPTIONS_ID, CORE_SIGNAL_SYMBOL, type CallContext, type CallOrigin, type CategoryDefinition, type ComposedAnnotator, type ConstantResolver$1 as ConstantResolver, type Controller, type ControllerAction, type ControllerAffordance, type ControllerAnswerFn, type ControllerChoice, type ControllerError, type ControllerIssue, type ControllerListingPage, type ControllerListingPosition, type ControllerMethodDescription, type ControllerMethodSummary, type ControllerPagination, type ControllerParameterDescription, type ControllerPath, type ControllerQuestion, type ControllerResult, type ControllerSdk, type ControllerSelectPage, type ControllerState, type CoreApiError, CoreCancelledSignal, CoreDisposeError, CoreError, CoreErrorCode, type CoreErrorOptions, type CoreOptions, CoreSignal, type CreateSdkOptions, type DefaultConnectionSchemeInput, type DeprecatedPromptConfigChoice, type DeprecationLogger, type DeprecationWarning, type DispatchHttpRequestInput, type DisposeFn, type DynamicListResolver, type DynamicMember, type DynamicResolver$1 as DynamicResolver, type DynamicSearchResolver, type FieldsResolver, type FormattedItem, type Formatter, type FunctionDeprecation, type FunctionRegistryEntry, type HookAnnotator, type HookPlugin, type HttpAttemptContext, type HttpFetchInit, type HttpOperationContext, type HttpOperationStart, type HttpPipelineState, type HttpRequest, type HttpRequestInput, type HttpResponse, type InitializeHttpRequestInput, type LeafMeta, type LeafSummary, type LegacyMergePlugin, type LegacyPlugin, type ListItemsResult, type ListPromptConfig, type MethodAnnotator, type MethodAttachment, type MethodHooks, type MethodOverridePlugin, type MethodPlugin, type MethodScope, type Resolver as ModelResolver, type NegatableMetadata, type NormalizeConnectionInput, type NormalizedConnection, type OnMethodEnd, type OnMethodEndContext, type OnMethodStart, type OnMethodStartContext, type OutputDataValidationReport, type OutputFormatter, type OverridableMetaFields, type PaginatedSdkFunction, type PaginatedSdkResult, type Plugin, type PluginMeta, type PluginProvides, type PluginStack, type PluginSummary, type PluginSurface, type PositionalMetadata, type PrepareHttpRequestInput, type PromptConfig, type PromptConfigChoice, type PropertyPlugin, RETRY_HTTP_REQUEST_OPTIONS_ID, type ReceiveHttpResponseInput, type RegistryResult, type RequiredSdkOf, type ResolveConnectionInput, type Resolver$1 as Resolver, type ResolverConfig, type ResolverFieldItem, type ResolverMetadata, type ResolverPromptConfig, type ResolverRequirement, type ResolverType, type ResponseMeta, type RetryHttpRequestOptions, STABILITY_LEVELS, STABILITY_TITLES, type Sdk, type SdkContext, type SdkContextCarrier, type SdkPage, type SendHttpRequest, type StabilityLevel, type StabilityNotice, type StabilityNoticeLogger, type StandInId, type StaticResolver$1 as StaticResolver, type ValidResolvers, addPlugin, applyStabilityLabel, attemptHttpRequestPlugin, authorizeHttpRequestPlugin, canonicalInputSchema, composePlugins, concatLists, concatPaginated, coreOptionsPluginRef, createAsyncContext, createController, createCoreError, createCorePlugin, createDeprecationLogger, createFunction, createPaginatedFunction, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createPrefixedCursor, createSdk, createStabilityNoticeLogger, createValidator, dangerousContextPlugin, declareDefault, declareMethod, declareOptionalMethod, declareOptionalProperty, declarePlugin, declareProperty, decodeIncomingCursor, defaultConnectionSchemePlugin, defaultLogDeprecation, defineFormatter, defineHook, defineLegacyMerge, defineMethod, defineMethodOverride, defineOverride, definePlugin, defineProperty, defineResolver, dispatchHttpRequestPlugin, disposeSdk, fetchPlugin, fromFunctionPlugin, getContext, getCoreErrorCause, getCoreErrorCode, getCurrentDepth, getCurrentScope, getFieldDescriptions, getNegatable, getOutputSchema, getRegistry, getRegistryPlugin, getSchemaDescription, initializeHttpRequestPlugin, isCoreCancelledSignal, isCoreError, isCoreSignal, isNestedMethodCall, isPositional, isTelemetryNested, normalizeConnectionPlugin, normalizeStability, objectShapeOf, omitExports, openEnum, paginate, paginateBuffered, paginateMaxItems, prepareHttpRequestPlugin, receiveHttpResponsePlugin, redactHeaders, redactHttpRequest, resolveConnectionPlugin, resolvePlugin, retryHttpRequestOptionsPluginRef, retryHttpRequestPlugin, runInMethodScope, runWithTelemetryContext, selectExports, sendHttpRequestPlugin, splitPrefixedCursor, toIterable, toSnakeCase, toTitleCase, unwrapSchema, validateOptions, withOutputSchema, withPositional, withResolver };