@zapier/kitcore 0.19.0 → 0.21.0

package/dist/index.cjs

@@ -38,20 +38,13 @@ __export(index_exports, {
   attemptHttpRequestPlugin: () => attemptHttpRequestPlugin,
   authorizeHttpRequestPlugin: () => authorizeHttpRequestPlugin,
   canonicalInputSchema: () => canonicalInputSchema,
-  composePlugins: () => composePlugins,
   concatLists: () => concatLists,
   concatPaginated: () => concatPaginated,
   coreOptionsPluginRef: () => coreOptionsPluginRef,
   createAsyncContext: () => createAsyncContext,
   createController: () => createController,
   createCoreError: () => createCoreError,
-  createCorePlugin: () => createCorePlugin,
   createDeprecationLogger: () => createDeprecationLogger,
-  createFunction: () => createFunction,
-  createPaginatedFunction: () => createPaginatedFunction,
-  createPaginatedPluginMethod: () => createPaginatedPluginMethod,
-  createPluginMethod: () => createPluginMethod,
-  createPluginStack: () => createPluginStack,
   createPrefixedCursor: () => createPrefixedCursor,
   createSdk: () => createSdk,
   createStabilityNoticeLogger: () => createStabilityNoticeLogger,
@@ -68,7 +61,6 @@ __export(index_exports, {
   defaultLogDeprecation: () => defaultLogDeprecation,
   defineFormatter: () => defineFormatter,
   defineHook: () => defineHook,
-  defineLegacyMerge: () => defineLegacyMerge,
   defineMethod: () => defineMethod,
   defineMethodOverride: () => defineMethodOverride,
   defineOverride: () => defineOverride,
@@ -78,7 +70,6 @@ __export(index_exports, {
   dispatchHttpRequestPlugin: () => dispatchHttpRequestPlugin,
   disposeSdk: () => disposeSdk,
   fetchPlugin: () => fetchPlugin,
-  fromFunctionPlugin: () => fromFunctionPlugin,
   getContext: () => getContext,
   getCoreErrorCause: () => getCoreErrorCause,
   getCoreErrorCode: () => getCoreErrorCode,
@@ -130,902 +121,915 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/utils/string-utils.ts
-function toTitleCase(input) {
-  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-]+/g, " ").replace(/\s+/g, " ").trim().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
-}
-function toSnakeCase(input) {
-  let result = input.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s\-]+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase();
-  if (/^[0-9]/.test(result)) {
-    result = "_" + result;
-  }
-  return result;
-}
-function pluralize(word) {
-  if (/s$/i.test(word)) return word;
-  if (/[bcdfghjklmnpqrstvwxz]y$/i.test(word)) {
-    return word.slice(0, -1) + "ies";
-  }
-  return word + "s";
+// src/utils/logging.ts
+function createDeprecationLogger(tag) {
+  const loggedDeprecations = /* @__PURE__ */ new Set();
+  return {
+    logDeprecation(message) {
+      if (loggedDeprecations.has(message)) return;
+      loggedDeprecations.add(message);
+      console.warn(`[${tag}] Deprecation: ${message}`);
+    },
+    resetDeprecationWarnings() {
+      loggedDeprecations.clear();
+    }
+  };
 }
-function pluralizeLastWord(title) {
-  const words = title.split(" ");
-  return [...words.slice(0, -1), pluralize(words[words.length - 1])].join(" ");
+var { logDeprecation, resetDeprecationWarnings } = createDeprecationLogger("core");
+function createStabilityNoticeLogger(tag) {
+  const loggedNotices = /* @__PURE__ */ new Set();
+  return {
+    logStabilityNotice(message) {
+      if (loggedNotices.has(message)) return;
+      loggedNotices.add(message);
+      console.warn(`[${tag}] ${message}`);
+    },
+    resetStabilityNotices() {
+      loggedNotices.clear();
+    }
+  };
 }
+var { logStabilityNotice, resetStabilityNotices } = createStabilityNoticeLogger("core");
 
-// src/utils/schema-utils.ts
-var import_zod = require("zod");
-function canonicalInputSchema(schema) {
-  if (schema instanceof import_zod.z.ZodUnion) {
-    return schema.options[0];
-  }
-  return schema;
+// src/model/shared.ts
+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) };
 }
-function unwrapSchema(schema) {
-  let inner = schema;
-  let required = true;
-  for (; ; ) {
-    if (inner instanceof import_zod.z.ZodOptional || inner instanceof import_zod.z.ZodDefault) {
-      required = false;
-      inner = inner.unwrap();
-    } else if (inner instanceof import_zod.z.ZodNullable) {
-      inner = inner.unwrap();
-    } else {
-      break;
+function makeId(name, namespace, kind = "leaf") {
+  validateName(name, kind);
+  if (namespace !== void 0) validateNamespace(namespace);
+  return namespace ? `${namespace}/${name}` : name;
+}
+var NAME_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var SEGMENT_RE = /^@?[A-Za-z0-9._-]+$/;
+function validateName(name, kind) {
+  if (name === "") throw new Error("Plugin name must not be empty.");
+  if (kind === "leaf") {
+    if (!NAME_RE.test(name)) {
+      throw new Error(
+        `Plugin name "${name}" must be a valid JS identifier (it is the binding name).`
+      );
     }
+  } else if (!SEGMENT_RE.test(name)) {
+    throw new Error(
+      `Plugin name "${name}" must be package-like (letters, digits, ".", "_", "-", optional leading "@") with no "/".`
+    );
   }
-  return { inner, required };
 }
-function objectShapeOf(schema) {
-  const canonical = canonicalInputSchema(schema);
-  if (!canonical) return void 0;
-  const { inner } = unwrapSchema(canonical);
-  if (inner instanceof import_zod.z.ZodObject) {
-    return inner.shape;
+function validateNamespace(namespace) {
+  if (namespace === "") throw new Error("Plugin namespace must not be empty.");
+  for (const segment of namespace.split("/")) {
+    if (!SEGMENT_RE.test(segment)) {
+      throw new Error(
+        `Plugin namespace "${namespace}" is invalid: each "/"-separated segment must be package-like (letters, digits, ".", "_", "-", optional leading "@").`
+      );
+    }
   }
-  return void 0;
 }
-function getOutputSchema(inputSchema) {
-  return inputSchema._zod.def.outputSchema;
-}
-function withOutputSchema(inputSchema, outputSchema) {
-  Object.assign(inputSchema._zod.def, {
-    outputSchema
-  });
-  return inputSchema;
+function isStandIn(plugin) {
+  return (plugin.pluginType === "method" || plugin.pluginType === "property" || plugin.pluginType === "aggregate") && plugin.standIn === true;
 }
-function withResolver(schema, config) {
-  schema._zod.def.resolverMeta = config;
-  return schema;
+function pickDefined(source, keys) {
+  const out = {};
+  for (const key of keys) {
+    if (source[key] !== void 0) out[key] = source[key];
+  }
+  return out;
 }
-function getSchemaDescription(schema) {
-  return schema.description;
+
+// src/model/types.ts
+var OVERRIDABLE_META_KEYS = [
+  "description",
+  "categories",
+  "itemType",
+  "returnType",
+  "packages",
+  "experimental",
+  "deprecation",
+  "supportsJsonOutput"
+];
+var METHOD_META_KEYS = Object.keys({
+  description: true,
+  categories: true,
+  packages: true,
+  stability: true,
+  experimental: true,
+  deprecation: true,
+  type: true,
+  itemType: true,
+  returnType: true,
+  confirm: true,
+  aliases: true,
+  supportsJsonOutput: true
+});
+var PROPERTY_META_KEYS = Object.keys({
+  description: true,
+  categories: true,
+  packages: true,
+  stability: true,
+  experimental: true,
+  deprecation: true
+});
+var PLUGIN_TYPES = new Set(
+  Object.keys({
+    method: true,
+    property: true,
+    aggregate: true,
+    hook: true,
+    "method-override": true
+  })
+);
+
+// src/model/plugin-argument.ts
+function assertKnownPluginType({
+  plugin,
+  where
+}) {
+  const { pluginType, id } = plugin;
+  if (PLUGIN_TYPES.has(pluginType)) return;
+  throw new Error(
+    `${where}: "${id}" has unknown pluginType "${pluginType}". A descriptor comes from a \`define*\` factory.`
+  );
 }
-function getFieldDescriptions(schema) {
-  const descriptions = {};
-  const shape = schema.shape;
-  for (const [key, fieldSchema] of Object.entries(shape)) {
-    if (fieldSchema instanceof import_zod.z.ZodType && fieldSchema.description) {
-      descriptions[key] = fieldSchema.description;
-    }
+function assertDescriptorShape(value, { where, arrayFix }) {
+  const pluginType = value?.pluginType;
+  if (typeof pluginType !== "string") {
+    const got = Array.isArray(value) ? `an array of ${value.length}. ${arrayFix}` : typeof value === "function" ? "a function, which was the old `(sdk) => provides` plugin shape" : `${value === null ? "null" : typeof value} with no \`pluginType\``;
+    throw new Error(
+      `${where}: expected a plugin descriptor built by a \`define*\` factory, but got ${got}.`
+    );
   }
-  return descriptions;
+  assertKnownPluginType({ plugin: value, where });
 }
-function withPositional(schema) {
-  Object.assign(schema._zod.def, {
-    positionalMeta: { positional: true }
+function assertPluginArgument(plugin, { caller, asRoot }) {
+  assertDescriptorShape(plugin, {
+    where: caller,
+    arrayFix: asRoot ? "Wrap them in definePlugin({ exports })" : "Add each entry in its own call"
   });
-  return schema;
-}
-function schemaHasPositionalMeta(schema) {
-  return "positionalMeta" in schema._zod.def;
-}
-function isPositional(schema) {
-  if (schemaHasPositionalMeta(schema) && schema._zod.def.positionalMeta?.positional) {
-    return true;
-  }
-  if (schema instanceof import_zod.z.ZodOptional) {
-    return isPositional(schema._zod.def.innerType);
+  const { id, pluginType } = plugin;
+  if (isStandIn(plugin)) {
+    throw new Error(
+      `${caller}: "${id}" is a declare* stand-in, which declares a dependency rather than providing one, so there is nothing to ${asRoot ? "build" : "add"}. Pass the real plugin that implements this id.`
+    );
   }
-  if (schema instanceof import_zod.z.ZodDefault) {
-    return isPositional(schema._zod.def.innerType);
+  if (!asRoot) return;
+  if (pluginType === "hook") {
+    throw new Error(
+      `createSdk: "${id}" is a defineHook. A hook contributes wraps and observers and surfaces nothing, so it cannot be a root. Export it from a definePlugin and build that instead.`
+    );
   }
-  return false;
-}
-function getNegatable(schema) {
-  const negatable = schema.meta?.()?.negatable;
-  if (negatable === true) return true;
-  if (typeof negatable === "string" && negatable.length > 0) return negatable;
-  if (schema instanceof import_zod.z.ZodOptional || schema instanceof import_zod.z.ZodDefault) {
-    return getNegatable(schema._zod.def.innerType);
+  if (pluginType === "method-override") {
+    throw new Error(
+      `createSdk: "${id}" is an override. It patches a method that another plugin defines, so it cannot be a root. Put it in a definePlugin's \`imports\` alongside the plugin it patches.`
+    );
   }
-  return void 0;
-}
-function openEnum(values, description) {
-  return import_zod.z.union([import_zod.z.enum(values), import_zod.z.string()]).describe(description);
 }
 
-// src/utils/stability.ts
-var STABILITY_LEVELS = ["stable", "beta", "experimental"];
-var STABILITY_TITLES = {
-  stable: "Stable",
-  beta: "Beta",
-  experimental: "Experimental"
-};
-function normalizeStability(meta) {
-  if (meta.stability !== void 0) {
-    return STABILITY_LEVELS.includes(meta.stability) ? meta.stability : "experimental";
-  }
-  return meta.experimental ? "experimental" : "stable";
-}
-function applyStabilityLabel({
-  description,
-  stability,
-  placement = "suffix"
+// src/model/define.ts
+function normalizeImports({
+  imports: deps,
+  owner
 }) {
-  if (stability === void 0 || stability === "stable") return description;
-  return placement === "prefix" ? `[${STABILITY_TITLES[stability]}] ${description}` : `${description} (${stability})`;
-}
-
-// src/registry.ts
-function resolveCategoryDefinition(ref) {
-  const def = typeof ref === "string" ? { key: ref } : ref;
-  const title = def.title ?? toTitleCase(def.key);
-  return {
-    key: def.key,
-    title,
-    titlePlural: def.titlePlural ?? pluralizeLastWord(title)
+  if (!deps) return { plugins: [], bindings: [] };
+  const seen = /* @__PURE__ */ new Map();
+  const bindings = [];
+  const add = (binding, id, optional) => {
+    const priorId = seen.get(binding);
+    if (priorId !== void 0 && priorId !== id) {
+      throw new Error(
+        `Import binding "${binding}" is declared twice. Two different plugins ("${priorId}" and "${id}") bind the same name; wrap one in selectExports to rename it.`
+      );
+    }
+    if (priorId === void 0) {
+      seen.set(binding, id);
+      bindings.push(optional ? { binding, id, optional } : { binding, id });
+    }
   };
-}
-function buildRegistry({
-  sdk,
-  meta,
-  formatters,
-  resolvers,
-  positional,
-  skipInputValidation,
-  packageFilter
-}) {
-  const definitionsByKey = /* @__PURE__ */ new Map();
-  const objectDeclaredKeys = /* @__PURE__ */ new Set();
-  for (const m of Object.values(meta)) {
-    for (const ref of m.categories ?? []) {
-      const key = typeof ref === "string" ? ref : ref.key;
-      if (typeof ref === "object") {
-        objectDeclaredKeys.add(key);
-        definitionsByKey.set(key, resolveCategoryDefinition(ref));
-      } else if (!objectDeclaredKeys.has(key)) {
-        definitionsByKey.set(key, resolveCategoryDefinition(ref));
+  deps.forEach((plugin, index) => {
+    assertDescriptorShape(plugin, {
+      where: `${owner}, imports[${index}]`,
+      arrayFix: "Spread it into the list"
+    });
+  });
+  for (const plugin of deps) {
+    if (plugin.pluginType === "aggregate") {
+      for (const [binding, child] of Object.entries(plugin.exports)) {
+        add(binding, child.id);
       }
+    } else if (plugin.pluginType === "hook" || plugin.pluginType === "method-override") {
+    } else {
+      add(plugin.name, plugin.id, plugin.optional);
     }
   }
-  if (!definitionsByKey.has("other")) {
-    definitionsByKey.set("other", resolveCategoryDefinition("other"));
-  }
-  const knownCategories = Array.from(definitionsByKey.keys());
-  const functions = Object.keys(meta).filter((key) => {
-    const property = sdk[key];
-    if (typeof property === "function") return true;
-    const [rootKey] = key.split(".");
-    const rootProperty = sdk[rootKey];
-    return typeof rootProperty === "object" && rootProperty !== null;
-  }).map((key) => {
-    const m = meta[key];
-    const stability = normalizeStability(m);
-    return {
-      name: key,
-      description: m.description,
-      type: m.type,
-      itemType: m.itemType,
-      returnType: m.returnType,
-      inputSchema: canonicalInputSchema(m.inputSchema),
-      outputSchema: m.outputSchema,
-      positional: positional?.[key],
-      skipInputValidation: skipInputValidation?.[key],
-      categories: (m.categories ?? []).map(
-        (c) => typeof c === "string" ? c : c.key
-      ),
-      resolvers: resolvers?.[key],
-      formatter: formatters?.[key],
-      stability,
-      // Deprecated derived read, literal by name: only the experimental
-      // tier reads true. Beta reads false — the "not stable" warning duty
-      // lives in `stability` and the runtime notice, not this boolean.
-      experimental: stability === "experimental",
-      packages: m.packages,
-      confirm: m.confirm ?? (m.type === "delete" ? "delete" : void 0),
-      deprecation: m.deprecation,
-      aliases: m.aliases,
-      supportsJsonOutput: m.supportsJsonOutput ?? true
-    };
-  }).sort((a, b) => a.name.localeCompare(b.name));
-  const filteredFunctions = packageFilter ? functions.filter((f) => !f.packages || f.packages.includes(packageFilter)) : functions;
-  const filteredCategories = knownCategories.slice().sort((a, b) => {
-    if (a === "other") return 1;
-    if (b === "other") return -1;
-    return definitionsByKey.get(a).title.localeCompare(definitionsByKey.get(b).title);
-  }).map((categoryKey) => {
-    const categoryFunctions = filteredFunctions.filter(
-      (f) => f.categories.includes(categoryKey) || categoryKey === "other" && !f.categories.some((c) => knownCategories.includes(c))
-    ).map((f) => f.name).sort();
-    const def = definitionsByKey.get(categoryKey);
-    return {
-      key: categoryKey,
-      title: def.title,
-      titlePlural: def.titlePlural,
-      functions: categoryFunctions
-    };
-  }).filter((category) => category.functions.length > 0);
-  return { functions: filteredFunctions, categories: filteredCategories };
+  return { plugins: deps, bindings };
 }
-
-// src/utils/build-hooks.ts
-var isolated = /* @__PURE__ */ new WeakSet();
-function isolate(observer) {
-  if (!observer) return void 0;
-  if (isolated.has(observer)) return observer;
-  const wrapped = (ctx) => {
-    try {
-      observer(ctx);
-    } catch (error) {
-      console.error(
-        "[core] A method-lifecycle observer threw and was ignored. Observers are fire-and-forget and must not throw.",
-        error
+function formatDynamicMemberName(path) {
+  return path.map((seg) => typeof seg === "string" ? seg : `{${seg.param}}`).join(".");
+}
+function collectDynamicMembers(members) {
+  if (!members?.length) return void 0;
+  return members.map((member) => {
+    const root = member.path[0];
+    if (typeof root !== "string") {
+      throw new Error(
+        "defineProperty: a dynamicMember path must start with a literal segment (the owning binding), not a { param }."
       );
     }
-  };
-  isolated.add(wrapped);
-  return wrapped;
-}
-function composeVoid(existing, added) {
-  const wrappedExisting = isolate(existing);
-  const wrappedAdded = isolate(added);
-  if (!wrappedExisting) return wrappedAdded;
-  if (!wrappedAdded) return wrappedExisting;
-  const composed = (ctx) => {
-    wrappedExisting(ctx);
-    wrappedAdded(ctx);
-  };
-  isolated.add(composed);
-  return composed;
-}
-function composeAnnotators(existing, added) {
-  if (!existing) return added;
-  if (!added) return existing;
-  return (ctx) => ({ ...existing(ctx), ...added(ctx) });
-}
-function buildHooks(existing, added) {
-  const result = {};
-  const start2 = composeVoid(existing.onMethodStart, added.onMethodStart);
-  if (start2) result.onMethodStart = start2;
-  const end = composeVoid(existing.onMethodEnd, added.onMethodEnd);
-  if (end) result.onMethodEnd = end;
-  const annotator = composeAnnotators(existing.annotator, added.annotator);
-  if (annotator) result.annotator = annotator;
-  return result;
+    const { path, ...fields } = member;
+    return {
+      ...fields,
+      name: formatDynamicMemberName(path),
+      rootBinding: root
+    };
+  });
 }
-
-// src/utils/logging.ts
-function createDeprecationLogger(tag) {
-  const loggedDeprecations = /* @__PURE__ */ new Set();
-  return {
-    logDeprecation(message) {
-      if (loggedDeprecations.has(message)) return;
-      loggedDeprecations.add(message);
-      console.warn(`[${tag}] Deprecation: ${message}`);
-    },
-    resetDeprecationWarnings() {
-      loggedDeprecations.clear();
-    }
+function defineMethod(configOrRef, refConfig) {
+  const config = refConfig === void 0 ? configOrRef : {
+    ...refConfig,
+    name: configOrRef.name,
+    namespace: configOrRef.namespace
   };
-}
-var { logDeprecation, resetDeprecationWarnings } = createDeprecationLogger("core");
-function createStabilityNoticeLogger(tag) {
-  const loggedNotices = /* @__PURE__ */ new Set();
+  const deps = normalizeImports({
+    imports: config.imports,
+    owner: `defineMethod "${config.name}"`
+  });
   return {
-    logStabilityNotice(message) {
-      if (loggedNotices.has(message)) return;
-      loggedNotices.add(message);
-      console.warn(`[${tag}] ${message}`);
-    },
-    resetStabilityNotices() {
-      loggedNotices.clear();
-    }
+    ...config,
+    pluginType: "method",
+    id: makeId(config.name, config.namespace),
+    imports: deps.plugins,
+    importBindings: deps.bindings
   };
 }
-var { logStabilityNotice, resetStabilityNotices } = createStabilityNoticeLogger("core");
-
-// src/types/errors.ts
-var CORE_ERROR_SYMBOL = Symbol.for("kitcore.error");
-var CoreErrorCode = {
-  Validation: "VALIDATION_ERROR",
-  Unknown: "UNKNOWN_ERROR"
-};
-var CoreError = class extends Error {
-  constructor(message, options = {}) {
-    super(message);
-    this.name = "CoreError";
-    if (options.statusCode !== void 0) this.statusCode = options.statusCode;
-    if (options.errors !== void 0) this.errors = options.errors;
-    if (options.cause !== void 0) this.cause = options.cause;
-    if (options.response !== void 0) this.response = options.response;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-function createCoreError(options, adaptError) {
-  const error = adaptError?.(options) ?? new CoreError(options.message, { cause: options.cause });
-  Object.defineProperty(error, CORE_ERROR_SYMBOL, {
-    value: true,
-    enumerable: false,
-    configurable: true,
-    writable: false
-  });
-  Object.defineProperty(error, "coreCode", {
-    value: options.code,
-    enumerable: false,
-    configurable: true,
-    writable: false
-  });
-  return error;
-}
-function isCoreError(value) {
-  return Boolean(
-    value && typeof value === "object" && value[CORE_ERROR_SYMBOL] === true
+function assertOverridable(target, fields) {
+  const offered = Object.keys(fields).filter(
+    (key) => !OVERRIDABLE_META_KEYS.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_META_KEYS.join(", ")}.`
   );
 }
-function getCoreErrorCode(value) {
-  if (!isCoreError(value)) return void 0;
-  return value.coreCode;
-}
-function getCoreErrorCause(value) {
-  if (!isCoreError(value)) return void 0;
-  return value.cause;
+function buildOverride(target, namespace, fields) {
+  assertOverridable(target, fields);
+  return {
+    pluginType: "method-override",
+    name: `override:${target}`,
+    id: namespace ? `${namespace}/override:${target}` : `override:${target}`,
+    target,
+    imports: [],
+    importBindings: [],
+    patch: pickDefined(fields, OVERRIDABLE_META_KEYS)
+  };
 }
-
-// src/utils/pagination-utils.ts
-var CURSOR_VERSION = 1;
-var CURSOR_SOURCE = {
-  API: "api",
-  SDK: "sdk",
-  CONCAT: "concat"
-};
-function encodeBase64(str) {
-  return btoa(
-    Array.from(
-      new TextEncoder().encode(str),
-      (b) => String.fromCharCode(b)
-    ).join("")
-  );
+function defineOverride(ref, config = {}) {
+  const { namespace, ...fields } = config;
+  return buildOverride(ref.id, namespace, fields);
 }
-function decodeBase64(str) {
-  return new TextDecoder().decode(
-    Uint8Array.from(atob(str), (c) => c.charCodeAt(0))
+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 encodeApiCursor(cursor) {
-  const envelope = {
-    v: CURSOR_VERSION,
-    source: CURSOR_SOURCE.API,
-    cursor
-  };
-  return encodeBase64(JSON.stringify(envelope));
+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 encodeSdkCursor(offset, cursor) {
-  const envelope = {
-    v: CURSOR_VERSION,
-    source: CURSOR_SOURCE.SDK,
-    cursor,
-    offset
+function defineResolver(config) {
+  const deps = normalizeImports({
+    imports: config.imports,
+    owner: "defineResolver"
+  });
+  const base = { imports: deps.plugins, importBindings: deps.bindings };
+  assertRequirementPaths(config.requireParameters);
+  const gates = {
+    requireParameters: config.requireParameters
   };
-  return encodeBase64(JSON.stringify(envelope));
-}
-function decodeIncomingCursor(incoming) {
-  if (!incoming) {
-    return { offset: 0, cursor: void 0 };
-  }
-  try {
-    const decoded = decodeBase64(incoming);
-    const envelope = JSON.parse(decoded);
-    if (envelope.v !== CURSOR_VERSION) {
-      return { offset: 0, cursor: incoming };
-    }
-    if (envelope.source === CURSOR_SOURCE.SDK) {
-      return { offset: envelope.offset ?? 0, cursor: envelope.cursor };
-    }
-    if (envelope.source === CURSOR_SOURCE.API) {
-      return { offset: 0, cursor: envelope.cursor };
-    }
-    return { offset: 0, cursor: incoming };
-  } catch {
-    return { offset: 0, cursor: incoming };
+  switch (config.type) {
+    case "static":
+      return {
+        ...base,
+        ...gates,
+        type: "static",
+        inputType: config.inputType,
+        placeholder: config.placeholder
+      };
+    case "constant":
+      return { ...base, ...gates, type: "constant", value: config.value };
+    case "info":
+      return { ...base, type: "info", text: config.text ?? "" };
+    case "object":
+      return {
+        ...base,
+        ...gates,
+        type: "object",
+        properties: config.properties,
+        definitions: config.definitions,
+        getProperties: config.getProperties,
+        additionalKeys: config.additionalKeys
+      };
+    case "array":
+      return {
+        ...base,
+        ...gates,
+        type: "array",
+        items: config.items,
+        minItems: config.minItems,
+        maxItems: config.maxItems,
+        itemValueType: config.itemValueType,
+        definitions: config.definitions
+      };
+    default:
+      return {
+        ...base,
+        ...gates,
+        type: "dynamic",
+        inputType: config.inputType,
+        placeholder: config.placeholder,
+        getContext: config.getContext,
+        listItems: config.listItems,
+        prompt: config.prompt,
+        validate: config.validate,
+        tryResolveWithoutPrompt: config.tryResolveWithoutPrompt,
+        tryResolveFromSearch: config.tryResolveFromSearch
+      };
   }
 }
-function createPrefixedCursor(prefix, cursor) {
-  if (!cursor) {
-    return `${prefix}::`;
-  }
-  return `${prefix}::${cursor}`;
+function defineFormatter(config) {
+  const deps = normalizeImports({
+    imports: config.imports,
+    owner: "defineFormatter"
+  });
+  return {
+    imports: deps.plugins,
+    importBindings: deps.bindings,
+    getContext: config.getContext,
+    format: config.format
+  };
 }
-function splitPrefixedCursor(cursor, prefixes) {
-  if (!cursor) {
-    return [void 0, void 0];
-  }
-  const [prefix, ...rest] = cursor.split("::");
-  if (prefixes && !prefixes.includes(prefix)) {
-    return [void 0, cursor];
-  }
-  cursor = rest.join("::");
-  if (!cursor) {
-    return [prefix, void 0];
-  }
-  return [prefix, cursor];
+function declareMethod(config) {
+  const { name, namespace } = parseId(config.id);
+  const id = makeId(name, namespace);
+  return {
+    pluginType: "method",
+    name,
+    namespace,
+    id,
+    standIn: true,
+    imports: [],
+    importBindings: [],
+    run: () => {
+      throw new Error(
+        `Plugin "${id}" is a stand-in (declareMethod) with no implementation. Register the real plugin under this id.`
+      );
+    }
+  };
 }
-async function* paginateMaxItemsWithUnencodedCursor(pageFunction, pageOptions) {
-  let cursor = pageOptions?.cursor;
-  let totalItemsYielded = 0;
-  const maxItems = pageOptions?.maxItems;
-  const pageSize = pageOptions?.pageSize;
-  do {
-    const options = {
-      ...pageOptions || {},
-      cursor,
-      pageSize: maxItems !== void 0 && pageSize !== void 0 ? Math.min(pageSize, maxItems) : pageSize
-    };
-    const page = await pageFunction(options);
-    if (maxItems !== void 0) {
-      const remainingItems = maxItems - totalItemsYielded;
-      if (page.data.length >= remainingItems) {
-        yield {
-          ...page,
-          data: page.data.slice(0, remainingItems),
-          nextCursor: void 0
-        };
-        break;
-      }
+function declareOptionalMethod(config) {
+  const { name, namespace } = parseId(config.id);
+  const id = makeId(name, namespace);
+  return {
+    pluginType: "method",
+    name,
+    namespace,
+    id,
+    standIn: true,
+    optional: true,
+    imports: [],
+    importBindings: [],
+    run: () => {
+      throw new Error(
+        `Plugin "${id}" is an optional stand-in (declareOptionalMethod) with no implementation. Its binding is \`undefined\` unless a real plugin is registered under this id.`
+      );
     }
-    yield page;
-    totalItemsYielded += page.data.length;
-    cursor = page.nextCursor;
-  } while (cursor);
+    // Requires nothing: a consumer that imports it still passes `createSdk`'s
+    // completeness check unprovided. The contract is still carried, so a
+    // provider that DOES appear under the id is checked against it. The
+    // `optional: true` literal drives `PluginSurface` to type the binding
+    // `| undefined`.
+  };
 }
-async function* paginateMaxItems(pageFunction, pageOptions) {
-  const { cursor } = decodeIncomingCursor(pageOptions?.cursor);
-  const options = {
-    ...pageOptions || {},
-    cursor
+function defineProperty(config, refConfig) {
+  const cfg = refConfig === void 0 ? config : {
+    ...refConfig,
+    name: config.name,
+    namespace: config.namespace
+  };
+  const deps = normalizeImports({
+    imports: cfg.imports,
+    owner: `defineProperty "${cfg.name}"`
+  });
+  return {
+    ...cfg,
+    pluginType: "property",
+    id: makeId(cfg.name, cfg.namespace),
+    imports: deps.plugins,
+    importBindings: deps.bindings,
+    dynamicMembers: collectDynamicMembers(cfg.dynamicMembers)
   };
-  for await (const page of paginateMaxItemsWithUnencodedCursor(
-    pageFunction,
-    options
-  )) {
-    yield {
-      ...page,
-      nextCursor: page.nextCursor ? encodeApiCursor(page.nextCursor) : void 0
-    };
-  }
 }
-async function* paginateBuffered(pageFunction, pageOptions) {
-  const pageSize = pageOptions?.pageSize;
-  const { offset: cursorOffset, cursor: initialCursor } = decodeIncomingCursor(
-    pageOptions?.cursor
-  );
-  const requestedMaxItems = pageOptions?.maxItems;
-  const options = {
-    ...pageOptions || {},
-    cursor: initialCursor,
-    // SDK cursors can carry an offset into a raw backend page. Since maxItems
-    // is expected to be relative to the resumed position, we add that offset
-    // so raw pagination still yields enough items after offset slicing.
-    maxItems: requestedMaxItems !== void 0 && cursorOffset > 0 ? requestedMaxItems + cursorOffset : requestedMaxItems
+function declareProperty(config) {
+  const { name, namespace } = parseId(config.id);
+  return {
+    pluginType: "property",
+    name,
+    namespace,
+    id: makeId(name, namespace),
+    standIn: true,
+    imports: [],
+    importBindings: []
   };
-  if (!pageSize) {
-    for await (const page of paginateMaxItemsWithUnencodedCursor(
-      pageFunction,
-      options
-    )) {
-      yield {
-        ...page,
-        nextCursor: page.nextCursor ? encodeApiCursor(page.nextCursor) : void 0
-      };
-    }
-    return;
-  }
-  let bufferedPages = [];
-  let isFirstPage = true;
-  let rawCursor;
-  for await (let page of paginateMaxItemsWithUnencodedCursor(
-    pageFunction,
-    options
-  )) {
-    const nextRawCursor = page.nextCursor;
-    if (isFirstPage) {
-      isFirstPage = false;
-      if (cursorOffset) {
-        page = {
-          ...page,
-          data: page.data.slice(cursorOffset)
-        };
-      }
-    }
-    const bufferedLength = bufferedPages.reduce(
-      (acc, p) => acc + p.data.length,
-      0
-    );
-    if (bufferedLength + page.data.length < pageSize) {
-      bufferedPages.push(page);
-      rawCursor = nextRawCursor;
-      continue;
-    }
-    const bufferedItems = bufferedPages.map((p) => p.data).flat();
-    const allItems = [...bufferedItems, ...page.data];
-    const pageItems = allItems.slice(0, pageSize);
-    const remainingItems = allItems.slice(pageItems.length);
-    if (remainingItems.length === 0) {
-      yield {
-        ...page,
-        data: pageItems,
-        nextCursor: nextRawCursor ? encodeApiCursor(nextRawCursor) : void 0
-      };
-      bufferedPages = [];
-      rawCursor = nextRawCursor;
-      continue;
-    }
-    yield {
-      ...page,
-      data: pageItems,
-      nextCursor: encodeSdkCursor(
-        page.data.length - remainingItems.length,
-        rawCursor
-      )
-    };
-    while (remainingItems.length > pageSize) {
-      const chunkItems = remainingItems.splice(0, pageSize);
-      yield {
-        ...page,
-        data: chunkItems,
-        nextCursor: encodeSdkCursor(
-          page.data.length - remainingItems.length,
-          rawCursor
-        )
-      };
-    }
-    bufferedPages = [
-      {
-        ...page,
-        data: remainingItems
-      }
-    ];
-    rawCursor = nextRawCursor;
-  }
-  if (bufferedPages.length > 0) {
-    const lastBufferedPage = bufferedPages.slice(-1)[0];
-    const bufferedItems = bufferedPages.map((p) => p.data).flat();
-    yield {
-      ...lastBufferedPage,
-      data: bufferedItems
-    };
-  }
 }
-var paginate = paginateBuffered;
-function encodeConcatCursor(index, cursor) {
-  const envelope = {
-    v: CURSOR_VERSION,
-    source: CURSOR_SOURCE.CONCAT,
-    index,
-    cursor
+function declareOptionalProperty(config) {
+  const { name, namespace } = parseId(config.id);
+  return {
+    pluginType: "property",
+    name,
+    namespace,
+    id: makeId(name, namespace),
+    standIn: true,
+    optional: true,
+    imports: [],
+    importBindings: []
+    // Requires nothing: a consumer that imports it still passes `createSdk`'s
+    // completeness check unprovided. The contract is the binding a consumer
+    // sees, `TValue | undefined`, which is also what a by-reference provider
+    // (`defineProperty(ref, { value })`) is allowed to pass. A consumer of an
+    // optional reference has to handle the absent case either way, so an
+    // explicit `undefined` breaks nothing a narrower contract would protect.
   };
-  return encodeBase64(JSON.stringify(envelope));
 }
-function decodeConcatCursor(incoming) {
-  if (!incoming) {
-    return { index: 0, cursor: void 0 };
+function declareDefault({
+  plugin
+}) {
+  return { ...plugin, defaultSource: plugin };
+}
+function defineHook(config) {
+  const deps = normalizeImports({
+    imports: config.imports,
+    owner: `defineHook "${config.name}"`
+  });
+  return {
+    pluginType: "hook",
+    name: config.name,
+    namespace: config.namespace,
+    id: makeId(config.name, config.namespace),
+    imports: deps.plugins,
+    importBindings: deps.bindings,
+    setup: config.setup,
+    dispose: config.dispose,
+    wrap: config.wrap,
+    observe: config.observe,
+    annotator: config.annotator
+  };
+}
+function declarePlugin(config) {
+  const { name, namespace } = parseId(config.id);
+  return {
+    pluginType: "aggregate",
+    name,
+    namespace,
+    id: makeId(name, namespace, "aggregate"),
+    standIn: true,
+    imports: [],
+    importBindings: [],
+    exports: normalizeExports(config.exports)
+  };
+}
+function definePlugin(config) {
+  const owner = `definePlugin "${config.name}"`;
+  const deps = normalizeImports({ imports: config.imports, owner });
+  config.exports?.forEach((element, index) => {
+    assertDescriptorShape(element, {
+      where: `${owner}, exports[${index}]`,
+      arrayFix: "Spread it into the list"
+    });
+  });
+  return {
+    pluginType: "aggregate",
+    name: config.name,
+    namespace: config.namespace,
+    id: makeId(config.name, config.namespace, "aggregate"),
+    // A re-export synthetic (`selectExports` / `omitExports`) is flattened by
+    // `normalizeExports` into bare bindings, which drops its own `imports:
+    // [source]`. That edge is how `omitExports` keeps an omitted (unbound) leaf
+    // materialized + addressable by id, so preserve every exported aggregate's
+    // imports as extra reachability edges here (bindings unaffected).
+    imports: [...deps.plugins, ...exportedAggregateImports(config.exports)],
+    importBindings: deps.bindings,
+    exports: normalizeExports(config.exports)
+  };
+}
+function exportedAggregateImports(exports2) {
+  if (!exports2) return [];
+  const out = [];
+  for (const element of exports2) {
+    if (element.pluginType === "aggregate") out.push(...element.imports);
   }
-  try {
-    const envelope = JSON.parse(decodeBase64(incoming));
-    if (envelope.v === CURSOR_VERSION && envelope.source === CURSOR_SOURCE.CONCAT && typeof envelope.index === "number") {
-      return { index: envelope.index, cursor: envelope.cursor };
+  return out;
+}
+function normalizeExports(exports2) {
+  const out = /* @__PURE__ */ Object.create(null);
+  if (!exports2) return out;
+  const add = (binding, leaf) => {
+    const existing = out[binding];
+    if (existing && existing.id !== leaf.id) {
+      throw new Error(
+        `definePlugin: duplicate export binding "${binding}". Two different plugins ("${existing.id}" and "${leaf.id}") bind the same name; wrap one in selectExports to rename it.`
+      );
+    }
+    out[binding] = leaf;
+  };
+  for (const element of exports2) {
+    if (element.pluginType === "aggregate") {
+      for (const [binding, child] of Object.entries(element.exports)) {
+        add(binding, child);
+      }
+    } else {
+      add(element.name, element);
     }
-  } catch {
   }
-  return { index: 0, cursor: incoming };
+  return out;
 }
-async function concatLists({
-  sources,
-  pageSize = 100,
-  cursor
-}) {
-  if (sources.length === 0) {
-    return { data: [] };
-  }
-  const pageFunction = async (options) => {
-    let { index, cursor: listCursor } = decodeConcatCursor(options.cursor);
-    while (index < sources.length) {
-      const page = await sources[index]({ cursor: listCursor });
-      const hasMoreInList = page.nextCursor != null;
-      if (page.data.length === 0 && !hasMoreInList) {
-        index++;
-        listCursor = void 0;
-        continue;
+
+// src/model/exports.ts
+var selectSeq = 0;
+function selectExports(source, ...specs) {
+  const selected = {};
+  const pick = (binding, fromName) => {
+    const child = source.exports[fromName];
+    if (!child) {
+      throw new Error(
+        `selectExports: "${source.id}" has no export "${fromName}".`
+      );
+    }
+    selected[binding] = child;
+  };
+  for (const spec of specs) {
+    if (typeof spec === "string") {
+      pick(spec, spec);
+    } else {
+      for (const [newName, fromName] of Object.entries(spec)) {
+        pick(newName, fromName);
       }
-      return {
-        data: page.data,
-        nextCursor: hasMoreInList ? encodeConcatCursor(index, page.nextCursor) : index < sources.length - 1 ? encodeConcatCursor(index + 1, void 0) : void 0
-      };
     }
-    return { data: [] };
+  }
+  const id = `${source.id}#select:${selectSeq++}`;
+  return {
+    pluginType: "aggregate",
+    name: makeId(`select`, source.name, "aggregate"),
+    id,
+    // Depend on the source so it is materialized; the selected bindings resolve
+    // to the source's own leaves (kept identity).
+    imports: [source],
+    importBindings: [],
+    exports: selected
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
   };
-  const result = await paginateBuffered(pageFunction, {
-    pageSize,
-    cursor
-  }).next();
-  return result.done ? { data: [] } : result.value;
-}
-function concatPaginated({
-  sources,
-  pageSize,
-  cursor
-}) {
-  logDeprecation("concatPaginated() is deprecated. Use concatLists() instead.");
-  return concatLists({ sources, pageSize, cursor });
 }
-function toIterable(source) {
-  logDeprecation(
-    "toIterable() is deprecated. Call .pages() on the paginated result instead."
-  );
-  return { [Symbol.asyncIterator]: () => source[Symbol.asyncIterator]() };
+function omitExports(source, omit) {
+  const omitSet = new Set(omit);
+  for (const name of omit) {
+    if (!(name in source.exports)) {
+      throw new Error(`omitExports: "${source.id}" has no export "${name}".`);
+    }
+  }
+  const kept = {};
+  for (const [binding, child] of Object.entries(source.exports)) {
+    if (!omitSet.has(binding)) kept[binding] = child;
+  }
+  return {
+    pluginType: "aggregate",
+    name: makeId(`omit`, source.name, "aggregate"),
+    id: `${source.id}#omit:${selectSeq++}`,
+    imports: [source],
+    importBindings: [],
+    exports: kept
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  };
 }
 
-// src/utils/promise-utils.ts
-function isPromiseLike(value) {
-  return value !== null && typeof value === "object" && typeof value.then === "function";
+// src/model/builtins.ts
+var import_zod2 = require("zod");
+
+// src/utils/string-utils.ts
+function toTitleCase(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-]+/g, " ").replace(/\s+/g, " ").trim().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+function toSnakeCase(input) {
+  let result = input.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s\-]+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase();
+  if (/^[0-9]/.test(result)) {
+    result = "_" + result;
+  }
+  return result;
+}
+function pluralize(word) {
+  if (/s$/i.test(word)) return word;
+  if (/[bcdfghjklmnpqrstvwxz]y$/i.test(word)) {
+    return word.slice(0, -1) + "ies";
+  }
+  return word + "s";
+}
+function pluralizeLastWord(title) {
+  const words = title.split(" ");
+  return [...words.slice(0, -1), pluralize(words[words.length - 1])].join(" ");
 }
 
-// src/utils/validation.ts
-var parseOrThrow = (schema, input, { adaptError } = {}) => {
-  const result = schema.safeParse(input);
-  if (!result.success) {
-    const errorMessages = result.error.issues.map((issue) => {
-      const path = issue.path.length > 0 ? issue.path.join(".") : "input";
-      return `${path}: ${issue.message}`;
-    });
-    throw createCoreError(
-      {
-        code: CoreErrorCode.Validation,
-        message: `Validation failed:
-  ${errorMessages.join("\n  ")}`,
-        details: {
-          zodErrors: result.error.issues,
-          input
-        }
-      },
-      adaptError
-    );
+// src/utils/schema-utils.ts
+var import_zod = require("zod");
+function canonicalInputSchema(schema) {
+  if (schema instanceof import_zod.z.ZodUnion) {
+    return schema.options[0];
   }
-  return result.data;
-};
-function createValidator(schema, { adaptError } = {}) {
-  return function validateFn(input) {
-    return parseOrThrow(schema, input, { adaptError });
-  };
-}
-var validateOptions = (schema, options, { adaptError } = {}) => parseOrThrow(schema, options, { adaptError });
-
-// src/utils/call-options.ts
-var import_zod2 = require("zod");
-var CallFrameworkOptionsSchema = import_zod2.z.object({
-  /** Page to fetch. Opaque to kitcore: the head's API defines the format. */
-  cursor: import_zod2.z.string().optional(),
-  /** Items per page. */
-  pageSize: import_zod2.z.number().int().min(1).optional(),
-  /** Stop after this many items, across pages. */
-  maxItems: import_zod2.z.number().int().min(0).optional(),
-  /** Bypass output validation for this one call. */
-  skipOutputDataValidation: import_zod2.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);
+  return schema;
 }
-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);
+function unwrapSchema(schema) {
+  let inner = schema;
+  let required = true;
+  for (; ; ) {
+    if (inner instanceof import_zod.z.ZodOptional || inner instanceof import_zod.z.ZodDefault) {
+      required = false;
+      inner = inner.unwrap();
+    } else if (inner instanceof import_zod.z.ZodNullable) {
+      inner = inner.unwrap();
+    } else {
+      break;
     }
   }
-  return [...refused];
+  return { inner, required };
 }
-function withoutKeys(options, keys) {
-  const next = {};
-  for (const [key, value] of Object.entries(options)) {
-    if (!keys.includes(key)) next[key] = value;
+function objectShapeOf(schema) {
+  const canonical = canonicalInputSchema(schema);
+  if (!canonical) return void 0;
+  const { inner } = unwrapSchema(canonical);
+  if (inner instanceof import_zod.z.ZodObject) {
+    return inner.shape;
   }
-  return next;
+  return void 0;
 }
-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 getOutputSchema(inputSchema) {
+  return inputSchema._zod.def.outputSchema;
 }
-function mergeCallOptions({
-  framework,
-  domain
-}) {
-  const claimed = Object.entries(framework);
-  if (!isRecord(domain) || claimed.length === 0) return domain;
-  return { ...domain, ...Object.fromEntries(claimed) };
+function withOutputSchema(inputSchema, outputSchema) {
+  Object.assign(inputSchema._zod.def, {
+    outputSchema
+  });
+  return inputSchema;
 }
-function withheldFromRun(policy) {
-  return new Set(policy.claims.filter((key) => !policy.injects.includes(key)));
+function withResolver(schema, config) {
+  schema._zod.def.resolverMeta = config;
+  return schema;
 }
-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 getSchemaDescription(schema) {
+  return schema.description;
 }
-function parseOrThrow2(schema, input, adaptError) {
-  const result = schema.safeParse(input);
-  if (result.success) return result.data;
-  throw toCoreError(result.error, input, adaptError);
+function getFieldDescriptions(schema) {
+  const descriptions = {};
+  const shape = schema.shape;
+  for (const [key, fieldSchema] of Object.entries(shape)) {
+    if (fieldSchema instanceof import_zod.z.ZodType && fieldSchema.description) {
+      descriptions[key] = fieldSchema.description;
+    }
+  }
+  return descriptions;
 }
-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}`;
+function withPositional(schema) {
+  Object.assign(schema._zod.def, {
+    positionalMeta: { positional: true }
   });
-  return createCoreError(
-    {
-      code: CoreErrorCode.Validation,
-      message: `Validation failed:
-  ${messages.join("\n  ")}`,
-      details: { zodErrors: error.issues, input }
-    },
-    adaptError
-  );
+  return schema;
 }
-
-// src/utils/async-context.ts
-var import_node_async_hooks = require("async_hooks");
-function createAsyncContext() {
-  let store = null;
-  try {
-    store = new import_node_async_hooks.AsyncLocalStorage();
-  } catch {
-    store = null;
-  }
-  return {
-    available: store !== null,
-    run(value, fn) {
-      return store ? store.run(value, fn) : fn();
-    },
-    get() {
-      return store?.getStore();
-    }
-  };
+function schemaHasPositionalMeta(schema) {
+  return "positionalMeta" in schema._zod.def;
 }
-
-// src/utils/method-scope.ts
-var scope = createAsyncContext();
-function getCurrentScope() {
-  return scope.get();
+function isPositional(schema) {
+  if (schemaHasPositionalMeta(schema) && schema._zod.def.positionalMeta?.positional) {
+    return true;
+  }
+  if (schema instanceof import_zod.z.ZodOptional) {
+    return isPositional(schema._zod.def.innerType);
+  }
+  if (schema instanceof import_zod.z.ZodDefault) {
+    return isPositional(schema._zod.def.innerType);
+  }
+  return false;
 }
-function getCurrentDepth() {
-  return getCurrentScope()?.depth ?? 0;
+function getNegatable(schema) {
+  const negatable = schema.meta?.()?.negatable;
+  if (negatable === true) return true;
+  if (typeof negatable === "string" && negatable.length > 0) return negatable;
+  if (schema instanceof import_zod.z.ZodOptional || schema instanceof import_zod.z.ZodDefault) {
+    return getNegatable(schema._zod.def.innerType);
+  }
+  return void 0;
 }
-function isNestedMethodCall() {
-  if (!scope.available) return true;
-  const store = scope.get();
-  return store !== void 0 && store.depth > 0;
+function openEnum(values, description) {
+  return import_zod.z.union([import_zod.z.enum(values), import_zod.z.string()]).describe(description);
 }
-var observerReentrancy = 0;
-function runIsolatedObserver(fn) {
-  observerReentrancy++;
-  try {
-    fn();
-  } catch {
-  } finally {
-    observerReentrancy--;
+
+// src/utils/stability.ts
+var STABILITY_LEVELS = ["stable", "beta", "experimental"];
+var STABILITY_TITLES = {
+  stable: "Stable",
+  beta: "Beta",
+  experimental: "Experimental"
+};
+function normalizeStability(meta) {
+  if (meta.stability !== void 0) {
+    return STABILITY_LEVELS.includes(meta.stability) ? meta.stability : "experimental";
   }
+  return meta.experimental ? "experimental" : "stable";
 }
-function isInsideObserver() {
-  return observerReentrancy > 0;
+function applyStabilityLabel({
+  description,
+  stability,
+  placement = "suffix"
+}) {
+  if (stability === void 0 || stability === "stable") return description;
+  return placement === "prefix" ? `[${STABILITY_TITLES[stability]}] ${description}` : `${description} (${stability})`;
 }
-function runInMethodScope(fn) {
-  if (!scope.available) return fn();
-  const currentDepth = scope.get()?.depth ?? -1;
-  return scope.run({ depth: currentDepth + 1 }, fn);
+
+// src/registry.ts
+function resolveCategoryDefinition(ref) {
+  const def = typeof ref === "string" ? { key: ref } : ref;
+  const title = def.title ?? toTitleCase(def.key);
+  return {
+    key: def.key,
+    title,
+    titlePlural: def.titlePlural ?? pluralizeLastWord(title)
+  };
+}
+function buildRegistry({
+  sdk,
+  sources,
+  packageFilter
+}) {
+  const definitionsByKey = /* @__PURE__ */ new Map();
+  const objectDeclaredKeys = /* @__PURE__ */ new Set();
+  for (const m of Object.values(sources)) {
+    for (const ref of m.categories ?? []) {
+      const key = typeof ref === "string" ? ref : ref.key;
+      if (typeof ref === "object") {
+        objectDeclaredKeys.add(key);
+        definitionsByKey.set(key, resolveCategoryDefinition(ref));
+      } else if (!objectDeclaredKeys.has(key)) {
+        definitionsByKey.set(key, resolveCategoryDefinition(ref));
+      }
+    }
+  }
+  if (!definitionsByKey.has("other")) {
+    definitionsByKey.set("other", resolveCategoryDefinition("other"));
+  }
+  const knownCategories = Array.from(definitionsByKey.keys());
+  const functions = Object.keys(sources).filter((key) => {
+    const property = sdk[key];
+    if (typeof property === "function") return true;
+    const [rootKey] = key.split(".");
+    const rootProperty = sdk[rootKey];
+    return typeof rootProperty === "object" && rootProperty !== null;
+  }).map((key) => {
+    const m = sources[key];
+    const stability = normalizeStability(m);
+    return {
+      name: key,
+      description: m.description,
+      type: m.type,
+      itemType: m.itemType,
+      returnType: m.returnType,
+      inputSchema: canonicalInputSchema(m.inputSchema),
+      outputSchema: m.outputSchema,
+      positional: m.positional,
+      skipInputValidation: m.skipInputValidation,
+      categories: (m.categories ?? []).map(
+        (c) => typeof c === "string" ? c : c.key
+      ),
+      resolvers: m.resolvers,
+      formatter: m.formatter,
+      stability,
+      // Deprecated derived read, literal by name: only the experimental
+      // tier reads true. Beta reads false — the "not stable" warning duty
+      // lives in `stability` and the runtime notice, not this boolean.
+      experimental: stability === "experimental",
+      packages: m.packages,
+      confirm: m.confirm ?? (m.type === "delete" ? "delete" : void 0),
+      deprecation: m.deprecation,
+      aliases: m.aliases,
+      supportsJsonOutput: m.supportsJsonOutput ?? true
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+  const filteredFunctions = packageFilter ? functions.filter((f) => !f.packages || f.packages.includes(packageFilter)) : functions;
+  const filteredCategories = knownCategories.slice().sort((a, b) => {
+    if (a === "other") return 1;
+    if (b === "other") return -1;
+    return definitionsByKey.get(a).title.localeCompare(definitionsByKey.get(b).title);
+  }).map((categoryKey) => {
+    const categoryFunctions = filteredFunctions.filter(
+      (f) => f.categories.includes(categoryKey) || categoryKey === "other" && !f.categories.some((c) => knownCategories.includes(c))
+    ).map((f) => f.name).sort();
+    const def = definitionsByKey.get(categoryKey);
+    return {
+      key: categoryKey,
+      title: def.title,
+      titlePlural: def.titlePlural,
+      functions: categoryFunctions
+    };
+  }).filter((category) => category.functions.length > 0);
+  return { functions: filteredFunctions, categories: filteredCategories };
 }
-var runWithTelemetryContext = runInMethodScope;
-var isTelemetryNested = isNestedMethodCall;
 
-// src/utils/call-context.ts
-var CALL_CONTEXT_BRAND = Symbol("kitcore.callContext");
-function isCallContext(value) {
-  return typeof value === "object" && value !== null && value[CALL_CONTEXT_BRAND] === true;
+// src/model/registry-support.ts
+function methodMetaOf(entry) {
+  const meta = pickDefined(entry, METHOD_META_KEYS);
+  return Object.keys(meta).length > 0 ? meta : void 0;
 }
-function generateCallId() {
-  try {
-    const webCrypto = globalThis.crypto;
-    if (webCrypto?.randomUUID) {
-      return webCrypto.randomUUID();
+function propertyMetaOf(entry) {
+  const meta = pickDefined(entry, PROPERTY_META_KEYS);
+  return Object.keys(meta).length > 0 ? meta : void 0;
+}
+function isDescribed(entry) {
+  const meta = entry.pluginType === "method" ? methodMetaOf(entry) : propertyMetaOf(entry);
+  return meta !== void 0;
+}
+function foldDynamicMembers(entry, surfaceBindings, sources) {
+  if (entry.pluginType !== "property" || !entry.dynamicMembers) return;
+  for (const member of entry.dynamicMembers) {
+    if (!surfaceBindings.has(member.rootBinding)) {
+      throw new Error(
+        `dynamicMember "${member.name}": its root "${member.rootBinding}" is not a surfaced member. A dynamic member's path must start with a real binding.`
+      );
     }
-    if (webCrypto?.getRandomValues) {
-      const bytes = webCrypto.getRandomValues(new Uint8Array(16));
-      const hex = Array.from(bytes, (byte, i) => {
-        const value = i === 6 ? byte & 15 | 64 : i === 8 ? byte & 63 | 128 : byte;
-        return value.toString(16).padStart(2, "0");
-      });
-      return [
-        hex.slice(0, 4).join(""),
-        hex.slice(4, 6).join(""),
-        hex.slice(6, 8).join(""),
-        hex.slice(8, 10).join(""),
-        hex.slice(10, 16).join("")
-      ].join("-");
+    sources[member.name] = member;
+  }
+}
+function collectRegistrySources(context) {
+  const sources = /* @__PURE__ */ Object.create(null);
+  const entries = [];
+  for (const [binding, id] of Object.entries(context.surface)) {
+    const entry = context.plugins[id];
+    if (entry?.pluginType !== "method" && entry?.pluginType !== "property") {
+      continue;
     }
-  } catch {
+    entries.push(entry);
+    if (isDescribed(entry)) sources[binding] = entry;
   }
-  return null;
+  const surfaceBindings = new Set(Object.keys(context.surface));
+  for (const entry of entries) {
+    foldDynamicMembers(entry, surfaceBindings, sources);
+  }
+  return sources;
 }
-function rootCallContext({
-  callOrigin = "surface"
-} = {}) {
-  return {
-    callId: generateCallId(),
-    depth: 0,
-    annotations: {},
-    callOrigin,
-    [CALL_CONTEXT_BRAND]: true
-  };
+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 childCallContext(parent) {
-  return {
-    callId: parent.callId,
-    depth: parent.depth + 1,
-    annotations: {},
-    callOrigin: parent.callOrigin,
-    [CALL_CONTEXT_BRAND]: true
-  };
+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)) {
+    const entry = context.plugins[id];
+    if (entry?.pluginType !== "method" && entry?.pluginType !== "property") {
+      continue;
+    }
+    surface[binding] = entry.pluginType === "property" && entry.getValue ? entry.getValue() : entry.value;
+  }
+  return buildRegistry({
+    sdk: surface,
+    sources: collectRegistrySources(context),
+    packageFilter
+  });
 }
 
 // src/utils/core-options.ts
@@ -1050,1376 +1054,1086 @@ function defaultLogStabilityNotice({
 }
 var CORE_OPTIONS_ID = "kitcore/coreOptions";
 
-// src/utils/function-utils.ts
-function resolveCoreOptions(context) {
-  const entry = context.plugins?.[CORE_OPTIONS_ID];
-  if (entry) {
-    return entry.getValue ? entry.getValue() : entry.value;
-  }
-  return context.core;
-}
-var INTERNAL_CALL = Symbol("kitcore.internalCall");
-function resolveCallContext(secondArg) {
-  return isCallContext(secondArg) ? secondArg : rootCallContext();
-}
-var hookAnnotatorReentrancy = 0;
-function applyAnnotations({
-  context,
-  methodName,
-  input,
-  hookAnnotator,
-  methodAnnotator
-}) {
-  if (hookAnnotator && !isInsideObserver() && context.depth === 0 && context.callOrigin !== "internal" && hookAnnotatorReentrancy === 0) {
-    hookAnnotatorReentrancy++;
+// src/model/builtins.ts
+var coreOptionsPluginRef = declareOptionalProperty({ id: CORE_OPTIONS_ID });
+var dangerousContextPlugin = {
+  pluginType: "property",
+  name: "context",
+  namespace: "kitcore",
+  id: "kitcore/context",
+  imports: [],
+  importBindings: [],
+  privileged: true
+};
+var getRegistryPlugin = defineMethod({
+  name: "getRegistry",
+  namespace: "kitcore",
+  imports: [dangerousContextPlugin],
+  inputSchema: import_zod2.z.object({ package: import_zod2.z.string().optional() }).optional(),
+  run: ({ imports, input }) => getCachedRegistry(imports.context, input?.package)
+});
+
+// src/utils/build-hooks.ts
+var isolated = /* @__PURE__ */ new WeakSet();
+function isolate(observer) {
+  if (!observer) return void 0;
+  if (isolated.has(observer)) return observer;
+  const wrapped = (ctx) => {
     try {
-      Object.assign(context.annotations, hookAnnotator({ methodName, input }));
-    } catch {
-    } finally {
-      hookAnnotatorReentrancy--;
+      observer(ctx);
+    } catch (error) {
+      console.error(
+        "[core] A method-lifecycle observer threw and was ignored. Observers are fire-and-forget and must not throw.",
+        error
+      );
     }
-  }
-  try {
-    Object.assign(context.annotations, methodAnnotator?.(input));
-  } catch {
-  }
-}
-function signalDeprecation(context, methodName, getDeprecation) {
-  if (isInsideObserver()) return;
-  const deprecation = getDeprecation?.();
-  if (!deprecation?.message) return;
-  const warning = {
-    type: "deprecation",
-    methodName,
-    deprecation
   };
-  const handler = resolveCoreOptions(context)?.logDeprecation ?? defaultLogDeprecation;
-  runIsolatedObserver(() => handler(warning));
+  isolated.add(wrapped);
+  return wrapped;
 }
-function signalStability(context, methodName, getStability) {
-  if (isInsideObserver()) return;
-  const stability = getStability?.();
-  if (!stability || stability === "stable") return;
-  const notice = {
-    type: "stability",
-    methodName,
-    stability
+function composeVoid(existing, added) {
+  const wrappedExisting = isolate(existing);
+  const wrappedAdded = isolate(added);
+  if (!wrappedExisting) return wrappedAdded;
+  if (!wrappedAdded) return wrappedExisting;
+  const composed = (ctx) => {
+    wrappedExisting(ctx);
+    wrappedAdded(ctx);
   };
-  const handler = resolveCoreOptions(context)?.logStabilityNotice ?? defaultLogStabilityNotice;
-  runIsolatedObserver(() => handler(notice));
+  isolated.add(composed);
+  return composed;
 }
-function normalizeError(error, adaptError) {
-  if (error instanceof Error) return error;
-  const message = typeof error === "object" && error !== null && "message" in error && typeof error.message === "string" ? error.message : String(error);
-  return createCoreError(
-    {
-      code: CoreErrorCode.Unknown,
-      message,
-      cause: error
-    },
-    adaptError
-  );
+function composeAnnotators(existing, added) {
+  if (!existing) return added;
+  if (!added) return existing;
+  return (ctx) => ({ ...existing(ctx), ...added(ctx) });
 }
-function createFunction(coreFn, options) {
-  const {
-    sdk,
-    schema,
-    name,
-    annotator,
-    frameworkOptions,
-    getDeprecation,
-    getStability
-  } = options;
-  const functionName = name || coreFn.name;
-  const namedFunctions = {
-    [functionName]: async function(callOptions) {
-      const internal = arguments[1];
-      const context = resolveCallContext(internal);
-      if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
-        signalDeprecation(sdk.context, functionName, getDeprecation);
-        signalStability(sdk.context, functionName, getStability);
-      }
-      return runInMethodScope(async () => {
-        const startTime = Date.now();
-        const normalizedOptions = callOptions ?? {};
-        const args = [normalizedOptions];
-        const depth = Math.max(context.depth, getCurrentDepth());
-        const insideObserver = isInsideObserver();
-        const hooks = insideObserver ? void 0 : sdk.context.hooks;
-        const adaptError = resolveCoreOptions(sdk.context)?.adaptError;
-        applyAnnotations({
-          context,
-          methodName: functionName,
-          input: normalizedOptions,
-          hookAnnotator: hooks?.annotator,
-          methodAnnotator: annotator
-        });
-        const hookBase = {
-          methodName: functionName,
-          args,
-          isPaginated: false,
-          depth,
-          callId: context.callId,
-          callOrigin: context.callOrigin,
-          annotations: context.annotations
-        };
-        hooks?.onMethodStart?.({ ...hookBase });
-        try {
-          const parsed = parseCallOptions(normalizedOptions, {
-            schema,
-            policy: frameworkOptions,
-            adaptError
-          });
-          const result = await coreFn(
-            mergeCallOptions(parsed),
-            context
-          );
-          hooks?.onMethodEnd?.({
-            ...hookBase,
-            durationMs: Date.now() - startTime
-          });
-          return result;
-        } catch (error) {
-          const normalizedError = normalizeError(error, adaptError);
-          hooks?.onMethodEnd?.({
-            ...hookBase,
-            durationMs: Date.now() - startTime,
-            error: normalizedError
-          });
-          throw normalizedError;
-        }
-      });
-    }
-  };
-  return namedFunctions[functionName];
+function buildHooks(existing, added) {
+  const result = {};
+  const start2 = composeVoid(existing.onMethodStart, added.onMethodStart);
+  if (start2) result.onMethodStart = start2;
+  const end = composeVoid(existing.onMethodEnd, added.onMethodEnd);
+  if (end) result.onMethodEnd = end;
+  const annotator = composeAnnotators(existing.annotator, added.annotator);
+  if (annotator) result.annotator = annotator;
+  return result;
 }
-function createRawFunction(coreFn, options) {
-  const {
-    sdk,
-    name,
-    schema,
-    positional,
-    annotator,
-    getDeprecation,
-    getStability
-  } = options;
-  return function(rawInput) {
-    const internal = arguments[1];
-    const context = resolveCallContext(internal);
-    if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
-      signalDeprecation(sdk.context, name, getDeprecation);
-      signalStability(sdk.context, name, getStability);
-    }
-    return runInMethodScope(() => {
-      const startTime = Date.now();
-      const depth = Math.max(context.depth, getCurrentDepth());
-      const insideObserver = isInsideObserver();
-      const hooks = insideObserver ? void 0 : sdk.context.hooks;
-      const adaptError = resolveCoreOptions(sdk.context)?.adaptError;
-      const input = schema ? rawInput ?? {} : rawInput;
-      applyAnnotations({
-        context,
-        methodName: name,
-        input,
-        hookAnnotator: hooks?.annotator,
-        methodAnnotator: annotator
-      });
-      const record = input;
-      const args = positional ? positional.filter((key) => record?.[key] !== void 0).map((key) => record?.[key]) : [input];
-      const hookBase = {
-        methodName: name,
-        args,
-        isPaginated: false,
-        depth,
-        callId: context.callId,
-        callOrigin: context.callOrigin,
-        annotations: context.annotations
-      };
-      hooks?.onMethodStart?.({ ...hookBase });
-      const fireEnd = (error) => {
-        hooks?.onMethodEnd?.({
-          ...hookBase,
-          durationMs: Date.now() - startTime,
-          ...error ? { error } : {}
-        });
-      };
-      try {
-        const parsed = schema ? validateOptions(schema, input, { adaptError }) : input;
-        const result = coreFn(parsed, context);
-        if (isPromiseLike(result)) {
-          return result.then(
-            (value) => {
-              fireEnd();
-              return value;
-            },
-            (error) => {
-              fireEnd(
-                error instanceof Error ? error : new Error(String(error))
-              );
-              throw error;
-            }
-          );
-        }
-        fireEnd();
-        return result;
-      } catch (error) {
-        fireEnd(error instanceof Error ? error : new Error(String(error)));
-        throw error;
-      }
-    });
-  };
+
+// src/model/root-keys.ts
+var RESERVED_ROOT_KEYS = /* @__PURE__ */ new Set(["context"]);
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
 }
-function isSdkPage(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const page = value;
-  if (!Array.isArray(page.data)) return false;
-  if (page.nextCursor !== void 0 && typeof page.nextCursor !== "string") {
-    return false;
+function assertNotReservedKeys({
+  keys,
+  caller
+}) {
+  for (const key of keys) {
+    if (!RESERVED_ROOT_KEYS.has(key)) continue;
+    throw new Error(
+      `${caller}: plugin attempted to register reserved root key "${key}". The framework writes this key itself, so the plugin's own value would never be reachable. Rename it.`
+    );
   }
-  return Object.keys(page).every((k) => k === "data" || k === "nextCursor");
 }
-function createPageFunction(coreFn, {
-  sdk,
-  adaptPage,
-  finalizePage
+function checkRootKeyCollisions({
+  target,
+  keys,
+  override,
+  caller
 }) {
-  const functionName = coreFn.name + "Page";
-  const namedFunctions = {
-    [functionName]: async function(options, callContext) {
-      try {
-        const response = await coreFn(options, callContext);
-        const page = adaptPage ? adaptPage(response) : response;
-        if (!isSdkPage(page)) {
-          throw new Error(
-            `${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, options) : page;
-      } catch (error) {
-        throw normalizeError(
-          error,
-          resolveCoreOptions(sdk.context)?.adaptError
-        );
-      }
+  assertNotReservedKeys({ keys, caller });
+  for (const key of keys) {
+    if (!override && hasOwn(target, key)) {
+      throw new Error(
+        `${caller}: duplicate root key "${key}". If the override is intentional, pass { override: true } in the options.`
+      );
     }
-  };
-  return namedFunctions[functionName];
+  }
 }
-function createPaginatedFunction(coreFn, options) {
-  const {
-    sdk,
-    schema,
-    name,
-    defaultPageSize,
-    adaptPage,
-    annotator,
-    finalizePage,
-    frameworkOptions,
-    getDeprecation,
-    getStability
-  } = options;
-  const pageFunction = createPageFunction(coreFn, {
-    sdk,
-    adaptPage,
-    finalizePage
+
+// src/types/errors.ts
+var CORE_ERROR_SYMBOL = Symbol.for("kitcore.error");
+var CoreErrorCode = {
+  Validation: "VALIDATION_ERROR",
+  Unknown: "UNKNOWN_ERROR",
+  /**
+   * The object handed to a framework reader is not an SDK `createSdk` built, so
+   * there is no plugin graph to read. A code rather than prose because a caller
+   * distinguishing "no registry here" from "the registry failed to build" has to
+   * match on something stable, and the message is not that.
+   */
+  NoSdkContext: "NO_SDK_CONTEXT_ERROR"
+};
+var CoreError = class extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "CoreError";
+    if (options.statusCode !== void 0) this.statusCode = options.statusCode;
+    if (options.errors !== void 0) this.errors = options.errors;
+    if (options.cause !== void 0) this.cause = options.cause;
+    if (options.response !== void 0) this.response = options.response;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+function createCoreError(options, adaptError) {
+  const error = adaptError?.(options) ?? new CoreError(options.message, { cause: options.cause });
+  Object.defineProperty(error, CORE_ERROR_SYMBOL, {
+    value: true,
+    enumerable: false,
+    configurable: true,
+    writable: false
   });
-  const functionName = name || coreFn.name;
-  const namedFunctions = {
-    [functionName]: function(callOptions) {
-      const internal = arguments[1];
-      const context = resolveCallContext(internal);
-      if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
-        signalDeprecation(sdk.context, functionName, getDeprecation);
-        signalStability(sdk.context, functionName, getStability);
-      }
-      return runInMethodScope(() => {
-        const startTime = Date.now();
-        const normalizedOptions = callOptions ?? {};
-        const args = [normalizedOptions];
-        const depth = Math.max(context.depth, getCurrentDepth());
-        const insideObserver = isInsideObserver();
-        const hooks = insideObserver ? void 0 : sdk.context.hooks;
-        const adaptError = resolveCoreOptions(sdk.context)?.adaptError;
-        applyAnnotations({
-          context,
-          methodName: functionName,
-          input: normalizedOptions,
-          hookAnnotator: hooks?.annotator,
-          methodAnnotator: annotator
-        });
-        const hookBase = {
-          methodName: functionName,
-          args,
-          isPaginated: true,
-          depth,
-          callId: context.callId,
-          callOrigin: context.callOrigin,
-          annotations: context.annotations
-        };
-        hooks?.onMethodStart?.({ ...hookBase });
-        try {
-          const validatedOptions = mergeCallOptions(
-            parseCallOptions(normalizedOptions, {
-              schema,
-              policy: frameworkOptions,
-              adaptError
-            })
-          );
-          const pageSize = validatedOptions.pageSize ?? defaultPageSize;
-          const optimizedOptions = {
-            ...validatedOptions,
-            pageSize
-          };
-          const iterator = paginate(
-            (pageOptions) => pageFunction(pageOptions, context),
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            optimizedOptions
-          );
-          const firstPagePromise = iterator.next().then((result) => {
-            if (result.done) {
-              throw new Error("Paginate should always iterate at least once");
-            }
-            return result.value;
-          });
-          if (hooks?.onMethodEnd) {
-            firstPagePromise.then(
-              () => {
-                hooks.onMethodEnd({
-                  ...hookBase,
-                  durationMs: Date.now() - startTime
-                });
-              },
-              (error) => {
-                hooks.onMethodEnd({
-                  ...hookBase,
-                  durationMs: Date.now() - startTime,
-                  error: error instanceof Error ? error : new Error(String(error))
-                });
-              }
-            );
-          }
-          const pageStream = async function* () {
-            yield await firstPagePromise;
-            for await (const page of iterator) {
-              yield page;
-            }
-          }();
-          return Object.assign(firstPagePromise, {
-            [Symbol.asyncIterator]() {
-              return pageStream;
-            },
-            pages: function() {
-              return {
-                [Symbol.asyncIterator]() {
-                  return pageStream;
-                }
-              };
-            },
-            items: function() {
-              return {
-                [Symbol.asyncIterator]: async function* () {
-                  for await (const page of pageStream) {
-                    for (const item of page.data) {
-                      yield item;
-                    }
-                  }
-                }
-              };
-            }
-          });
-        } catch (error) {
-          const normalizedError = normalizeError(error, adaptError);
-          hooks?.onMethodEnd?.({
-            ...hookBase,
-            durationMs: Date.now() - startTime,
-            error: normalizedError
-          });
-          throw normalizedError;
-        }
-      });
-    }
-  };
-  return namedFunctions[functionName];
+  Object.defineProperty(error, "coreCode", {
+    value: options.code,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+  return error;
+}
+function isCoreError(value) {
+  return Boolean(
+    value && typeof value === "object" && value[CORE_ERROR_SYMBOL] === true
+  );
+}
+function getCoreErrorCode(value) {
+  if (!isCoreError(value)) return void 0;
+  return value.coreCode;
+}
+function getCoreErrorCause(value) {
+  if (!isCoreError(value)) return void 0;
+  return value.cause;
+}
+
+// src/utils/pagination-utils.ts
+var CURSOR_VERSION = 1;
+var CURSOR_SOURCE = {
+  API: "api",
+  SDK: "sdk",
+  CONCAT: "concat"
+};
+function encodeBase64(str) {
+  return btoa(
+    Array.from(
+      new TextEncoder().encode(str),
+      (b) => String.fromCharCode(b)
+    ).join("")
+  );
 }
-
-// src/utils/plugin-utils.ts
-function createPluginMethod(sdk, config) {
-  logDeprecation(
-    "createPluginMethod() is deprecated. Author methods with defineMethod instead."
+function decodeBase64(str) {
+  return new TextDecoder().decode(
+    Uint8Array.from(atob(str), (c) => c.charCodeAt(0))
   );
-  const { name, inputSchema, handler, ...metaFields } = config;
-  const namedHandlers = {
-    [name]: async function(options) {
-      return handler({ sdk, options });
-    }
+}
+function encodeApiCursor(cursor) {
+  const envelope = {
+    v: CURSOR_VERSION,
+    source: CURSOR_SOURCE.API,
+    cursor
   };
-  const wrappedFn = createFunction(namedHandlers[name], {
-    sdk,
-    schema: inputSchema
-  });
-  return {
-    [name]: wrappedFn,
-    context: {
-      meta: {
-        [name]: {
-          ...metaFields,
-          ...inputSchema ? { inputSchema } : {}
-        }
-      }
-    }
+  return encodeBase64(JSON.stringify(envelope));
+}
+function encodeSdkCursor(offset, cursor) {
+  const envelope = {
+    v: CURSOR_VERSION,
+    source: CURSOR_SOURCE.SDK,
+    cursor,
+    offset
   };
+  return encodeBase64(JSON.stringify(envelope));
 }
-function createPaginatedPluginMethod(sdk, config) {
-  logDeprecation(
-    'createPaginatedPluginMethod() is deprecated. Author list methods with defineMethod output "list" instead.'
-  );
-  const {
-    name,
-    inputSchema,
-    handler,
-    adaptPage,
-    defaultPageSize,
-    ...metaFields
-  } = config;
-  const namedHandlers = {
-    [name]: function(options) {
-      return handler({ sdk, options });
+function decodeIncomingCursor(incoming) {
+  if (!incoming) {
+    return { offset: 0, cursor: void 0 };
+  }
+  try {
+    const decoded = decodeBase64(incoming);
+    const envelope = JSON.parse(decoded);
+    if (envelope.v !== CURSOR_VERSION) {
+      return { offset: 0, cursor: incoming };
     }
-  };
-  const wrappedFn = createPaginatedFunction(namedHandlers[name], {
-    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
-  });
-  return {
-    [name]: wrappedFn,
-    context: {
-      meta: {
-        [name]: {
-          ...metaFields,
-          ...inputSchema ? { inputSchema } : {}
-        }
-      }
+    if (envelope.source === CURSOR_SOURCE.SDK) {
+      return { offset: envelope.offset ?? 0, cursor: envelope.cursor };
     }
-  };
+    if (envelope.source === CURSOR_SOURCE.API) {
+      return { offset: 0, cursor: envelope.cursor };
+    }
+    return { offset: 0, cursor: incoming };
+  } catch {
+    return { offset: 0, cursor: incoming };
+  }
 }
-function splitPluginContribution(result) {
-  const { context, ...rootKeys } = result;
-  const { meta, hooks, ...contextRest } = context ?? {};
-  return {
-    rootKeys,
-    meta: meta ?? {},
-    hooks: hooks ?? {},
-    contextRest
-  };
+function createPrefixedCursor(prefix, cursor) {
+  if (!cursor) {
+    return `${prefix}::`;
+  }
+  return `${prefix}::${cursor}`;
 }
-var RESERVED_ROOT_KEYS = /* @__PURE__ */ new Set([
-  "context",
-  "getRegistry"
-]);
-function hasOwn(obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj, key);
+function splitPrefixedCursor(cursor, prefixes) {
+  if (!cursor) {
+    return [void 0, void 0];
+  }
+  const [prefix, ...rest] = cursor.split("::");
+  if (prefixes && !prefixes.includes(prefix)) {
+    return [void 0, cursor];
+  }
+  cursor = rest.join("::");
+  if (!cursor) {
+    return [prefix, void 0];
+  }
+  return [prefix, cursor];
 }
-function setOwn(target, key, value) {
-  Object.defineProperty(target, key, {
-    value,
-    enumerable: true,
-    configurable: true,
-    writable: true
-  });
+async function* paginateMaxItemsWithUnencodedCursor(pageFunction, pageOptions) {
+  let cursor = pageOptions?.cursor;
+  let totalItemsYielded = 0;
+  const maxItems = pageOptions?.maxItems;
+  const pageSize = pageOptions?.pageSize;
+  do {
+    const options = {
+      ...pageOptions || {},
+      cursor,
+      pageSize: maxItems !== void 0 && pageSize !== void 0 ? Math.min(pageSize, maxItems) : pageSize
+    };
+    const page = await pageFunction(options);
+    if (maxItems !== void 0) {
+      const remainingItems = maxItems - totalItemsYielded;
+      if (page.data.length >= remainingItems) {
+        yield {
+          ...page,
+          data: page.data.slice(0, remainingItems),
+          nextCursor: void 0
+        };
+        break;
+      }
+    }
+    yield page;
+    totalItemsYielded += page.data.length;
+    cursor = page.nextCursor;
+  } while (cursor);
+}
+async function* paginateMaxItems(pageFunction, pageOptions) {
+  const { cursor } = decodeIncomingCursor(pageOptions?.cursor);
+  const options = {
+    ...pageOptions || {},
+    cursor
+  };
+  for await (const page of paginateMaxItemsWithUnencodedCursor(
+    pageFunction,
+    options
+  )) {
+    yield {
+      ...page,
+      nextCursor: page.nextCursor ? encodeApiCursor(page.nextCursor) : void 0
+    };
+  }
 }
-function checkCollisions(target, source, kind, callerLabel, override) {
-  if (kind === "root key") {
-    checkRootKeyCollisions(target, Object.keys(source), override, callerLabel);
+async function* paginateBuffered(pageFunction, pageOptions) {
+  const pageSize = pageOptions?.pageSize;
+  const { offset: cursorOffset, cursor: initialCursor } = decodeIncomingCursor(
+    pageOptions?.cursor
+  );
+  const requestedMaxItems = pageOptions?.maxItems;
+  const options = {
+    ...pageOptions || {},
+    cursor: initialCursor,
+    // SDK cursors can carry an offset into a raw backend page. Since maxItems
+    // is expected to be relative to the resumed position, we add that offset
+    // so raw pagination still yields enough items after offset slicing.
+    maxItems: requestedMaxItems !== void 0 && cursorOffset > 0 ? requestedMaxItems + cursorOffset : requestedMaxItems
+  };
+  if (!pageSize) {
+    for await (const page of paginateMaxItemsWithUnencodedCursor(
+      pageFunction,
+      options
+    )) {
+      yield {
+        ...page,
+        nextCursor: page.nextCursor ? encodeApiCursor(page.nextCursor) : void 0
+      };
+    }
     return;
   }
-  for (const key of Object.keys(source)) {
-    if (!override && hasOwn(target, key)) {
-      throw new Error(
-        `${callerLabel}: duplicate ${kind} "${key}". If the override is intentional, pass { override: true } in the options.`
-      );
+  let bufferedPages = [];
+  let isFirstPage = true;
+  let rawCursor;
+  for await (let page of paginateMaxItemsWithUnencodedCursor(
+    pageFunction,
+    options
+  )) {
+    const nextRawCursor = page.nextCursor;
+    if (isFirstPage) {
+      isFirstPage = false;
+      if (cursorOffset) {
+        page = {
+          ...page,
+          data: page.data.slice(cursorOffset)
+        };
+      }
+    }
+    const bufferedLength = bufferedPages.reduce(
+      (acc, p) => acc + p.data.length,
+      0
+    );
+    if (bufferedLength + page.data.length < pageSize) {
+      bufferedPages.push(page);
+      rawCursor = nextRawCursor;
+      continue;
+    }
+    const bufferedItems = bufferedPages.map((p) => p.data).flat();
+    const allItems = [...bufferedItems, ...page.data];
+    const pageItems = allItems.slice(0, pageSize);
+    const remainingItems = allItems.slice(pageItems.length);
+    if (remainingItems.length === 0) {
+      yield {
+        ...page,
+        data: pageItems,
+        nextCursor: nextRawCursor ? encodeApiCursor(nextRawCursor) : void 0
+      };
+      bufferedPages = [];
+      rawCursor = nextRawCursor;
+      continue;
+    }
+    yield {
+      ...page,
+      data: pageItems,
+      nextCursor: encodeSdkCursor(
+        page.data.length - remainingItems.length,
+        rawCursor
+      )
+    };
+    while (remainingItems.length > pageSize) {
+      const chunkItems = remainingItems.splice(0, pageSize);
+      yield {
+        ...page,
+        data: chunkItems,
+        nextCursor: encodeSdkCursor(
+          page.data.length - remainingItems.length,
+          rawCursor
+        )
+      };
     }
+    bufferedPages = [
+      {
+        ...page,
+        data: remainingItems
+      }
+    ];
+    rawCursor = nextRawCursor;
+  }
+  if (bufferedPages.length > 0) {
+    const lastBufferedPage = bufferedPages.slice(-1)[0];
+    const bufferedItems = bufferedPages.map((p) => p.data).flat();
+    yield {
+      ...lastBufferedPage,
+      data: bufferedItems
+    };
+  }
+}
+var paginate = paginateBuffered;
+function encodeConcatCursor(index, cursor) {
+  const envelope = {
+    v: CURSOR_VERSION,
+    source: CURSOR_SOURCE.CONCAT,
+    index,
+    cursor
+  };
+  return encodeBase64(JSON.stringify(envelope));
+}
+function decodeConcatCursor(incoming) {
+  if (!incoming) {
+    return { index: 0, cursor: void 0 };
   }
-}
-function checkRootKeyCollisions(target, keys, override, callerLabel) {
-  for (const key of keys) {
-    if (RESERVED_ROOT_KEYS.has(key)) {
-      throw new Error(
-        `${callerLabel}: plugin attempted to register reserved root key "${key}". The SDK uses this key for its own accessor; rename the plugin's method.`
-      );
-    }
-    if (!override && hasOwn(target, key)) {
-      throw new Error(
-        `${callerLabel}: duplicate root key "${key}". If the override is intentional, pass { override: true } in the options.`
-      );
+  try {
+    const envelope = JSON.parse(decodeBase64(incoming));
+    if (envelope.v === CURSOR_VERSION && envelope.source === CURSOR_SOURCE.CONCAT && typeof envelope.index === "number") {
+      return { index: envelope.index, cursor: envelope.cursor };
     }
+  } catch {
   }
+  return { index: 0, cursor: incoming };
 }
-function applyOwnProperties(target, source) {
-  for (const key of Object.keys(source)) {
-    setOwn(target, key, source[key]);
+async function concatLists({
+  sources,
+  pageSize = 100,
+  cursor
+}) {
+  if (sources.length === 0) {
+    return { data: [] };
   }
-}
-function createPluginAccumulator(initialProperties = {}, initialContext = {}) {
-  const initialMeta = initialContext.meta ?? {};
-  const initialHooks = initialContext.hooks ?? {};
-  const context = {
-    ...initialContext,
-    meta: { ...initialMeta },
-    hooks: { ...initialHooks }
-  };
-  const view = { ...initialProperties, context };
-  return { view, context };
-}
-function mergeContribution(propertiesTarget, contextTarget, contribution, options) {
-  checkCollisions(
-    propertiesTarget,
-    contribution.rootKeys,
-    "root key",
-    options.callerLabel,
-    options.override
-  );
-  checkCollisions(
-    contextTarget.meta,
-    contribution.meta,
-    "context.meta key",
-    options.callerLabel,
-    options.override
-  );
-  checkCollisions(
-    contextTarget,
-    contribution.contextRest,
-    "context key",
-    options.callerLabel,
-    options.override
-  );
-  applyOwnProperties(propertiesTarget, contribution.rootKeys);
-  applyOwnProperties(contextTarget.meta, contribution.meta);
-  applyOwnProperties(contextTarget, contribution.contextRest);
-  contextTarget.hooks = buildHooks(contextTarget.hooks, contribution.hooks);
-}
-function applyPluginContribution(acc, contribution, options) {
-  mergeContribution(acc.view, acc.context, contribution, options);
-}
-function wrapAsSdk(properties, context) {
-  const sdk = {
-    ...properties,
-    context,
-    getRegistry(qopts) {
-      return buildRegistry({
-        sdk,
-        meta: context.meta,
-        packageFilter: qopts?.package
-      });
+  const pageFunction = async (options) => {
+    let { index, cursor: listCursor } = decodeConcatCursor(options.cursor);
+    while (index < sources.length) {
+      const page = await sources[index]({ cursor: listCursor });
+      const hasMoreInList = page.nextCursor != null;
+      if (page.data.length === 0 && !hasMoreInList) {
+        index++;
+        listCursor = void 0;
+        continue;
+      }
+      return {
+        data: page.data,
+        nextCursor: hasMoreInList ? encodeConcatCursor(index, page.nextCursor) : index < sources.length - 1 ? encodeConcatCursor(index + 1, void 0) : void 0
+      };
     }
+    return { data: [] };
   };
-  return sdk;
+  const result = await paginateBuffered(pageFunction, {
+    pageSize,
+    cursor
+  }).next();
+  return result.done ? { data: [] } : result.value;
 }
-function wrapAccumulatorAsSdk(acc) {
-  const { context: _ctx, ...rootKeys } = acc.view;
-  return wrapAsSdk(
-    rootKeys,
-    acc.context
-  );
+function concatPaginated({
+  sources,
+  pageSize,
+  cursor
+}) {
+  logDeprecation("concatPaginated() is deprecated. Use concatLists() instead.");
+  return concatLists({ sources, pageSize, cursor });
 }
-function applyPluginToSdk(sdk, plugin, options) {
-  const context = sdk.context;
-  const contribution = splitPluginContribution(
-    plugin(sdk)
+function toIterable(source) {
+  logDeprecation(
+    "toIterable() is deprecated. Call .pages() on the paginated result instead."
   );
-  mergeContribution(sdk, context, contribution, {
-    callerLabel: "addPlugin",
-    override: options.override === true
-  });
-  return contribution;
-}
-function resolveStack(head) {
-  const entries = [];
-  let node = head;
-  while (node) {
-    entries.unshift({ apply: node.entry, override: node.override });
-    node = node.prev;
-  }
-  return entries;
-}
-function composeStackHooks(hooks) {
-  let composed = {};
-  for (const h of hooks) composed = buildHooks(composed, h);
-  return composed;
+  return { [Symbol.asyncIterator]: () => source[Symbol.asyncIterator]() };
 }
-function collapseStackEntries(entries, callerLabel) {
-  return (outerSdk) => {
-    const { context: outerContext, ...outerProperties } = outerSdk ?? {};
-    const viewAcc = createPluginAccumulator(outerProperties, outerContext);
-    const contribsAcc = createPluginAccumulator();
-    const hooks = [];
-    for (const { apply, override } of entries) {
-      const contribution = splitPluginContribution(
-        apply(viewAcc.view)
-      );
-      const hookless = { ...contribution, hooks: {} };
-      applyPluginContribution(viewAcc, hookless, { callerLabel, override });
-      applyPluginContribution(contribsAcc, hookless, { callerLabel, override });
-      hooks.push(contribution.hooks);
-    }
-    const stackHooks = composeStackHooks(hooks);
-    viewAcc.context.hooks = buildHooks(viewAcc.context.hooks, stackHooks);
-    contribsAcc.context.hooks = stackHooks;
-    const { context: _ignored, ...contributedRoot } = contribsAcc.view;
-    return {
-      ...contributedRoot,
-      context: contribsAcc.context
-    };
-  };
+
+// src/utils/promise-utils.ts
+function isPromiseLike(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
 }
-function buildStackAccumulator(head, callerLabel) {
-  const entries = resolveStack(head);
-  const acc = createPluginAccumulator();
-  const hooks = [];
-  for (const { apply, override } of entries) {
-    const contribution = splitPluginContribution(
-      apply(acc.view)
-    );
-    applyPluginContribution(
-      acc,
-      { ...contribution, hooks: {} },
-      { callerLabel, override }
+
+// src/utils/validation.ts
+var parseOrThrow = (schema, input, { adaptError } = {}) => {
+  const result = schema.safeParse(input);
+  if (!result.success) {
+    const errorMessages = result.error.issues.map((issue) => {
+      const path = issue.path.length > 0 ? issue.path.join(".") : "input";
+      return `${path}: ${issue.message}`;
+    });
+    throw createCoreError(
+      {
+        code: CoreErrorCode.Validation,
+        message: `Validation failed:
+  ${errorMessages.join("\n  ")}`,
+        details: {
+          zodErrors: result.error.issues,
+          input
+        }
+      },
+      adaptError
     );
-    hooks.push(contribution.hooks);
-  }
-  acc.context.hooks = composeStackHooks(hooks);
-  return acc;
-}
-function composePlugins(...plugins) {
-  logDeprecation(
-    "composePlugins(...) is deprecated. Use createPluginStack().use(a).use(b).use(c).toPlugin({ name }) instead. The stack carries the same collision-detection and hook-composition behavior and supports per-step { override: true } for intentional duplicates."
-  );
-  let head = null;
-  for (const plugin of plugins) {
-    head = { entry: plugin, override: false, prev: head };
   }
-  const entries = resolveStack(head);
-  return collapseStackEntries(entries, "composePlugins");
-}
-function createPluginStack() {
-  logDeprecation(
-    "createPluginStack() is deprecated. Compose with definePlugin and build with createSdk instead."
-  );
-  return buildPluginStack(null, "createPluginStack");
-}
-function buildPluginStack(head, callerLabel) {
-  const stack = {
-    use(plugin, options) {
-      const next = {
-        entry: plugin,
-        override: options?.override === true,
-        prev: head
-      };
-      return buildPluginStack(next, callerLabel);
-    },
-    toPlugin() {
-      const entries = resolveStack(head);
-      return collapseStackEntries(entries, callerLabel);
-    },
-    toSdk() {
-      return wrapAccumulatorAsSdk(
-        buildStackAccumulator(head, callerLabel)
-      );
-    }
+  return result.data;
+};
+function createValidator(schema, { adaptError } = {}) {
+  return function validateFn(input) {
+    return parseOrThrow(schema, input, { adaptError });
   };
-  return stack;
 }
+var validateOptions = (schema, options, { adaptError } = {}) => parseOrThrow(schema, options, { adaptError });
 
-// src/model/shared.ts
-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) };
-}
-function makeId(name, namespace, kind = "leaf") {
-  validateName(name, kind);
-  if (namespace !== void 0) validateNamespace(namespace);
-  return namespace ? `${namespace}/${name}` : name;
+// src/utils/call-options.ts
+var import_zod3 = require("zod");
+var CallFrameworkOptionsSchema = import_zod3.z.object({
+  /** Page to fetch. Opaque to kitcore: the head's API defines the format. */
+  cursor: import_zod3.z.string().optional(),
+  /** Items per page. */
+  pageSize: import_zod3.z.number().int().min(1).optional(),
+  /** Stop after this many items, across pages. */
+  maxItems: import_zod3.z.number().int().min(0).optional(),
+  /** Bypass output validation for this one call. */
+  skipOutputDataValidation: import_zod3.z.boolean().optional()
+});
+var ITEM_FRAMEWORK_OPTIONS = {
+  claims: ["skipOutputDataValidation"],
+  injects: []
+};
+var LIST_FRAMEWORK_OPTIONS = {
+  claims: ["cursor", "pageSize", "maxItems", "skipOutputDataValidation"],
+  injects: ["cursor", "pageSize"]
+};
+var NO_FRAMEWORK_OPTIONS = {
+  claims: [],
+  injects: []
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var NAME_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-var SEGMENT_RE = /^@?[A-Za-z0-9._-]+$/;
-function validateName(name, kind) {
-  if (name === "") throw new Error("Plugin name must not be empty.");
-  if (kind === "leaf") {
-    if (!NAME_RE.test(name)) {
-      throw new Error(
-        `Plugin name "${name}" must be a valid JS identifier (it is the binding name).`
-      );
+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);
     }
-  } else if (!SEGMENT_RE.test(name)) {
-    throw new Error(
-      `Plugin name "${name}" must be package-like (letters, digits, ".", "_", "-", optional leading "@") with no "/".`
-    );
   }
+  return [...refused];
 }
-function validateNamespace(namespace) {
-  if (namespace === "") throw new Error("Plugin namespace must not be empty.");
-  for (const segment of namespace.split("/")) {
-    if (!SEGMENT_RE.test(segment)) {
-      throw new Error(
-        `Plugin namespace "${namespace}" is invalid: each "/"-separated segment must be package-like (letters, digits, ".", "_", "-", optional leading "@").`
-      );
-    }
+function withoutKeys(options, keys) {
+  const next = {};
+  for (const [key, value] of Object.entries(options)) {
+    if (!keys.includes(key)) next[key] = value;
   }
+  return next;
 }
-
-// src/model/types.ts
-var LEAF_META_KEYS = [
-  "description",
-  "categories",
-  "type",
-  "itemType",
-  "returnType",
-  "outputSchema",
-  "packages",
-  "stability",
-  "experimental",
-  "confirm",
-  "deprecation",
-  "aliases",
-  "supportsJsonOutput"
-];
-
-// src/model/define.ts
-function normalizeImports(deps) {
-  if (!deps) return { plugins: [], bindings: [] };
-  const seen = /* @__PURE__ */ new Map();
-  const bindings = [];
-  const add = (binding, id, optional) => {
-    const priorId = seen.get(binding);
-    if (priorId !== void 0 && priorId !== id) {
-      throw new Error(
-        `Import binding "${binding}" is declared twice. Two different plugins ("${priorId}" and "${id}") bind the same name; wrap one in selectExports to rename it.`
-      );
-    }
-    if (priorId === void 0) {
-      seen.set(binding, id);
-      bindings.push(optional ? { binding, id, optional } : { binding, id });
-    }
-  };
-  for (const plugin of deps) {
-    if (plugin.pluginType === "aggregate") {
-      for (const [binding, child] of Object.entries(plugin.exports)) {
-        add(binding, child.id);
-      }
-    } else if (plugin.pluginType === "hook") {
-    } else {
-      add(plugin.name, plugin.id, plugin.optional);
+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);
   }
-  return { plugins: deps, bindings };
-}
-function collectLeafMeta(config) {
-  let meta;
-  for (const key of LEAF_META_KEYS) {
-    if (config[key] !== void 0) (meta ?? (meta = {}))[key] = config[key];
+  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 meta;
+  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 formatDynamicMemberName(path) {
-  return path.map((seg) => typeof seg === "string" ? seg : `{${seg.param}}`).join(".");
+function parseOrThrow2(schema, input, adaptError) {
+  const result = schema.safeParse(input);
+  if (result.success) return result.data;
+  throw toCoreError(result.error, input, adaptError);
 }
-function collectDynamicMembers(members) {
-  if (!members?.length) return void 0;
-  return members.map((member) => {
-    const root = member.path[0];
-    if (typeof root !== "string") {
-      throw new Error(
-        "defineProperty: a dynamicMember path must start with a literal segment (the owning binding), not a { param }."
-      );
-    }
-    const leaf = collectLeafMeta(member) ?? {};
-    return {
-      name: formatDynamicMemberName(member.path),
-      rootBinding: root,
-      meta: member.inputSchema ? { ...leaf, inputSchema: member.inputSchema } : leaf
-    };
+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}`;
   });
-}
-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",
-    name: config.name,
-    namespace: config.namespace,
-    id: makeId(config.name, config.namespace),
-    imports: deps.plugins,
-    importBindings: deps.bindings,
-    inputSchema: config.inputSchema,
-    skipInputValidation: config.skipInputValidation,
-    skipOutputValidation: config.skipOutputValidation,
-    meta: collectLeafMeta(config),
-    resolvers: config.resolvers,
-    formatter: config.formatter,
-    annotator: config.annotator,
-    output: config.output,
-    positional: config.positional,
-    setup: config.setup,
-    dispose: config.dispose,
-    run: config.run
-  };
-}
-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(", ")}.`
+  return createCoreError(
+    {
+      code: CoreErrorCode.Validation,
+      message: `Validation failed:
+  ${messages.join("\n  ")}`,
+      details: { zodErrors: error.issues, input }
+    },
+    adaptError
   );
 }
-function buildOverride(target, namespace, fields) {
-  assertOverridable(target, fields);
+
+// src/utils/async-context.ts
+var import_node_async_hooks = require("async_hooks");
+function createAsyncContext() {
+  let store = null;
+  try {
+    store = new import_node_async_hooks.AsyncLocalStorage();
+  } catch {
+    store = null;
+  }
   return {
-    pluginType: "method-override",
-    name: `override:${target}`,
-    id: namespace ? `${namespace}/override:${target}` : `override:${target}`,
-    target,
-    imports: [],
-    importBindings: [],
-    meta: collectLeafMeta(fields)
+    available: store !== null,
+    run(value, fn) {
+      return store ? store.run(value, fn) : fn();
+    },
+    get() {
+      return store?.getStore();
+    }
   };
 }
-function defineOverride(ref, config = {}) {
-  const { namespace, ...fields } = config;
-  return buildOverride(ref.id, namespace, fields);
+
+// src/utils/method-scope.ts
+var scope = createAsyncContext();
+function getCurrentScope() {
+  return scope.get();
 }
-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 getCurrentDepth() {
+  return getCurrentScope()?.depth ?? 0;
 }
-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 isNestedMethodCall() {
+  if (!scope.available) return true;
+  const store = scope.get();
+  return store !== void 0 && store.depth > 0;
 }
-function defineResolver(config) {
-  const deps = normalizeImports(config.imports);
-  const base = { imports: deps.plugins, importBindings: deps.bindings };
-  assertRequirementPaths(config.requireParameters);
-  const gates = {
-    requireParameters: config.requireParameters
-  };
-  switch (config.type) {
-    case "static":
-      return {
-        ...base,
-        ...gates,
-        type: "static",
-        inputType: config.inputType,
-        placeholder: config.placeholder
-      };
-    case "constant":
-      return { ...base, ...gates, type: "constant", value: config.value };
-    case "info":
-      return { ...base, type: "info", text: config.text ?? "" };
-    case "object":
-      return {
-        ...base,
-        ...gates,
-        type: "object",
-        properties: config.properties,
-        definitions: config.definitions,
-        getProperties: config.getProperties,
-        additionalKeys: config.additionalKeys
-      };
-    case "array":
-      return {
-        ...base,
-        ...gates,
-        type: "array",
-        items: config.items,
-        minItems: config.minItems,
-        maxItems: config.maxItems,
-        itemValueType: config.itemValueType,
-        definitions: config.definitions
-      };
-    default:
-      return {
-        ...base,
-        ...gates,
-        type: "dynamic",
-        inputType: config.inputType,
-        placeholder: config.placeholder,
-        getContext: config.getContext,
-        listItems: config.listItems,
-        prompt: config.prompt,
-        validate: config.validate,
-        tryResolveWithoutPrompt: config.tryResolveWithoutPrompt,
-        tryResolveFromSearch: config.tryResolveFromSearch
-      };
+var observerReentrancy = 0;
+function runIsolatedObserver(fn) {
+  observerReentrancy++;
+  try {
+    fn();
+  } catch {
+  } finally {
+    observerReentrancy--;
   }
 }
-function defineFormatter(config) {
-  const deps = normalizeImports(config.imports);
-  return {
-    imports: deps.plugins,
-    importBindings: deps.bindings,
-    getContext: config.getContext,
-    format: config.format
-  };
+function isInsideObserver() {
+  return observerReentrancy > 0;
 }
-function declareMethod(config) {
-  const { name, namespace } = parseId(config.id);
-  const id = makeId(name, namespace);
-  return {
-    pluginType: "method",
-    name,
-    namespace,
-    id,
-    standIn: true,
-    imports: [],
-    importBindings: [],
-    run: () => {
-      throw new Error(
-        `Plugin "${id}" is a stand-in (declareMethod) with no implementation. Register the real plugin under this id.`
-      );
-    }
-  };
+function runInMethodScope(fn) {
+  if (!scope.available) return fn();
+  const currentDepth = scope.get()?.depth ?? -1;
+  return scope.run({ depth: currentDepth + 1 }, fn);
 }
-function declareOptionalMethod(config) {
-  const { name, namespace } = parseId(config.id);
-  const id = makeId(name, namespace);
-  return {
-    pluginType: "method",
-    name,
-    namespace,
-    id,
-    standIn: true,
-    optional: true,
-    imports: [],
-    importBindings: [],
-    run: () => {
-      throw new Error(
-        `Plugin "${id}" is an optional stand-in (declareOptionalMethod) with no implementation. Its binding is \`undefined\` unless a real plugin is registered under this id.`
-      );
-    }
-    // Requires nothing (phantom carrier `<never, never>`): a consumer that
-    // imports it still passes `createSdk`'s completeness check unprovided. The
-    // `optional: true` literal drives `PluginSurface` to type the binding
-    // `| undefined`.
-  };
+var runWithTelemetryContext = runInMethodScope;
+var isTelemetryNested = isNestedMethodCall;
+
+// src/utils/call-context.ts
+var CALL_CONTEXT_BRAND = Symbol("kitcore.callContext");
+function isCallContext(value) {
+  return typeof value === "object" && value !== null && value[CALL_CONTEXT_BRAND] === true;
 }
-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: cfg.name,
-    namespace: cfg.namespace,
-    id: makeId(cfg.name, cfg.namespace),
-    imports: deps.plugins,
-    importBindings: deps.bindings,
-    setup: cfg.setup,
-    dispose: cfg.dispose,
-    value: cfg.value,
-    get: cfg.get,
-    meta: collectLeafMeta(cfg),
-    dynamicMembers: collectDynamicMembers(cfg.dynamicMembers)
-  };
+function generateCallId() {
+  try {
+    const webCrypto = globalThis.crypto;
+    if (webCrypto?.randomUUID) {
+      return webCrypto.randomUUID();
+    }
+    if (webCrypto?.getRandomValues) {
+      const bytes = webCrypto.getRandomValues(new Uint8Array(16));
+      const hex = Array.from(bytes, (byte, i) => {
+        const value = i === 6 ? byte & 15 | 64 : i === 8 ? byte & 63 | 128 : byte;
+        return value.toString(16).padStart(2, "0");
+      });
+      return [
+        hex.slice(0, 4).join(""),
+        hex.slice(4, 6).join(""),
+        hex.slice(6, 8).join(""),
+        hex.slice(8, 10).join(""),
+        hex.slice(10, 16).join("")
+      ].join("-");
+    }
+  } catch {
+  }
+  return null;
 }
-function declareProperty(config) {
-  const { name, namespace } = parseId(config.id);
+function rootCallContext({
+  callOrigin = "surface"
+} = {}) {
   return {
-    pluginType: "property",
-    name,
-    namespace,
-    id: makeId(name, namespace),
-    standIn: true,
-    imports: [],
-    importBindings: []
+    callId: generateCallId(),
+    depth: 0,
+    annotations: {},
+    callOrigin,
+    [CALL_CONTEXT_BRAND]: true
   };
 }
-function declareOptionalProperty(config) {
-  const { name, namespace } = parseId(config.id);
+function childCallContext(parent) {
   return {
-    pluginType: "property",
-    name,
-    namespace,
-    id: makeId(name, namespace),
-    standIn: true,
-    optional: true,
-    imports: [],
-    importBindings: []
-    // Requires nothing (phantom carrier `<never, never>`): a consumer that
-    // imports it still passes `createSdk`'s completeness check unprovided. The
-    // import binding is still typed `TValue | undefined` from the descriptor.
+    callId: parent.callId,
+    depth: parent.depth + 1,
+    annotations: {},
+    callOrigin: parent.callOrigin,
+    [CALL_CONTEXT_BRAND]: true
   };
 }
-function declareDefault({
-  plugin
-}) {
-  return { ...plugin, defaultSource: plugin };
-}
-function defineHook(config) {
-  const deps = normalizeImports(config.imports);
-  return {
-    pluginType: "hook",
-    name: config.name,
-    namespace: config.namespace,
-    id: makeId(config.name, config.namespace),
-    imports: deps.plugins,
-    importBindings: deps.bindings,
-    setup: config.setup,
-    dispose: config.dispose,
-    wrap: config.wrap,
-    observe: config.observe,
-    annotator: config.annotator
-  };
+
+// src/utils/function-utils.ts
+function resolveCoreOptions(context) {
+  const entry = context.plugins[CORE_OPTIONS_ID];
+  if (!entry) return void 0;
+  return entry.pluginType === "property" && entry.getValue ? entry.getValue() : entry.value;
 }
-function declarePlugin(config) {
-  const { name, namespace } = parseId(config.id);
-  return {
-    pluginType: "aggregate",
-    name,
-    namespace,
-    id: makeId(name, namespace, "aggregate"),
-    standIn: true,
-    imports: [],
-    importBindings: [],
-    exports: normalizeExports(config.exports)
-  };
+var INTERNAL_CALL = Symbol("kitcore.internalCall");
+function resolveCallContext(secondArg) {
+  return isCallContext(secondArg) ? secondArg : rootCallContext();
 }
-function definePlugin(fnOrConfig) {
-  if (typeof fnOrConfig === "function") {
-    logDeprecation(
-      "definePlugin(fn) (the function form) is deprecated. Author plugins with defineMethod/defineProperty/definePlugin({ ... }) instead."
-    );
-    return fnOrConfig;
+var hookAnnotatorReentrancy = 0;
+function applyAnnotations({
+  context,
+  methodName,
+  input,
+  hookAnnotator,
+  methodAnnotator
+}) {
+  if (hookAnnotator && !isInsideObserver() && context.depth === 0 && context.callOrigin !== "internal" && hookAnnotatorReentrancy === 0) {
+    hookAnnotatorReentrancy++;
+    try {
+      Object.assign(context.annotations, hookAnnotator({ methodName, input }));
+    } catch {
+    } finally {
+      hookAnnotatorReentrancy--;
+    }
   }
-  const config = fnOrConfig;
-  const deps = normalizeImports(config.imports);
-  return {
-    pluginType: "aggregate",
-    name: config.name,
-    namespace: config.namespace,
-    id: makeId(config.name, config.namespace, "aggregate"),
-    // A re-export synthetic (`selectExports` / `omitExports`) is flattened by
-    // `normalizeExports` into bare bindings, which drops its own `imports:
-    // [source]`. That edge is how `omitExports` keeps an omitted (unbound) leaf
-    // materialized + addressable by id, so preserve every exported aggregate's
-    // imports as extra reachability edges here (bindings unaffected).
-    imports: [...deps.plugins, ...exportedAggregateImports(config.exports)],
-    importBindings: deps.bindings,
-    exports: normalizeExports(config.exports)
-  };
-}
-function exportedAggregateImports(exports2) {
-  if (!exports2) return [];
-  const out = [];
-  for (const element of exports2) {
-    if (element.pluginType === "aggregate") out.push(...element.imports);
+  try {
+    Object.assign(context.annotations, methodAnnotator?.(input));
+  } catch {
   }
-  return out;
 }
-function normalizeExports(exports2) {
-  if (!exports2) return {};
-  const out = {};
-  const add = (binding, leaf) => {
-    const existing = out[binding];
-    if (existing && existing.id !== leaf.id) {
-      throw new Error(
-        `definePlugin: duplicate export binding "${binding}". Two different plugins ("${existing.id}" and "${leaf.id}") bind the same name; wrap one in selectExports to rename it.`
-      );
-    }
-    out[binding] = leaf;
+function signalDeprecation(context, methodName, getDeprecation) {
+  if (isInsideObserver()) return;
+  const deprecation = getDeprecation?.();
+  if (!deprecation?.message) return;
+  const warning = {
+    type: "deprecation",
+    methodName,
+    deprecation
   };
-  for (const element of exports2) {
-    if (element.pluginType === "aggregate") {
-      for (const [binding, child] of Object.entries(element.exports)) {
-        add(binding, child);
-      }
-    } else {
-      add(element.name, element);
-    }
-  }
-  return out;
+  const handler = resolveCoreOptions(context)?.logDeprecation ?? defaultLogDeprecation;
+  runIsolatedObserver(() => handler(warning));
 }
-
-// src/model/exports.ts
-var selectSeq = 0;
-function selectExports(source, ...specs) {
-  const selected = {};
-  const pick = (binding, fromName) => {
-    const child = source.exports[fromName];
-    if (!child) {
-      throw new Error(
-        `selectExports: "${source.id}" has no export "${fromName}".`
-      );
-    }
-    selected[binding] = child;
+function signalStability(context, methodName, getStability) {
+  if (isInsideObserver()) return;
+  const stability = getStability?.();
+  if (!stability || stability === "stable") return;
+  const notice = {
+    type: "stability",
+    methodName,
+    stability
   };
-  for (const spec of specs) {
-    if (typeof spec === "string") {
-      pick(spec, spec);
-    } else {
-      for (const [newName, fromName] of Object.entries(spec)) {
-        pick(newName, fromName);
+  const handler = resolveCoreOptions(context)?.logStabilityNotice ?? defaultLogStabilityNotice;
+  runIsolatedObserver(() => handler(notice));
+}
+function normalizeError(error, adaptError) {
+  if (error instanceof Error) return error;
+  const message = typeof error === "object" && error !== null && "message" in error && typeof error.message === "string" ? error.message : String(error);
+  return createCoreError(
+    {
+      code: CoreErrorCode.Unknown,
+      message,
+      cause: error
+    },
+    adaptError
+  );
+}
+function createFunction(coreFn, options) {
+  const {
+    sdkContext,
+    schema,
+    name,
+    annotator,
+    frameworkOptions,
+    getDeprecation,
+    getStability
+  } = options;
+  const functionName = name || coreFn.name;
+  const namedFunctions = {
+    [functionName]: async function(callOptions) {
+      const internal = arguments[1];
+      const context = resolveCallContext(internal);
+      if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
+        signalDeprecation(sdkContext, functionName, getDeprecation);
+        signalStability(sdkContext, functionName, getStability);
       }
+      return runInMethodScope(async () => {
+        const startTime = Date.now();
+        const normalizedOptions = callOptions ?? {};
+        const args = [normalizedOptions];
+        const depth = Math.max(context.depth, getCurrentDepth());
+        const insideObserver = isInsideObserver();
+        const hooks = insideObserver ? void 0 : sdkContext.hooks;
+        const adaptError = resolveCoreOptions(sdkContext)?.adaptError;
+        applyAnnotations({
+          context,
+          methodName: functionName,
+          input: normalizedOptions,
+          hookAnnotator: hooks?.annotator,
+          methodAnnotator: annotator
+        });
+        const hookBase = {
+          methodName: functionName,
+          args,
+          isPaginated: false,
+          depth,
+          callId: context.callId,
+          callOrigin: context.callOrigin,
+          annotations: context.annotations
+        };
+        hooks?.onMethodStart?.({ ...hookBase });
+        try {
+          const parsed = parseCallOptions(normalizedOptions, {
+            schema,
+            policy: frameworkOptions,
+            adaptError
+          });
+          const result = await coreFn(
+            mergeCallOptions(parsed),
+            context
+          );
+          hooks?.onMethodEnd?.({
+            ...hookBase,
+            durationMs: Date.now() - startTime
+          });
+          return result;
+        } catch (error) {
+          const normalizedError = normalizeError(error, adaptError);
+          hooks?.onMethodEnd?.({
+            ...hookBase,
+            durationMs: Date.now() - startTime,
+            error: normalizedError
+          });
+          throw normalizedError;
+        }
+      });
     }
-  }
-  const id = `${source.id}#select:${selectSeq++}`;
-  return {
-    pluginType: "aggregate",
-    name: makeId(`select`, source.name, "aggregate"),
-    id,
-    // Depend on the source so it is materialized; the selected bindings resolve
-    // to the source's own leaves (kept identity).
-    imports: [source],
-    importBindings: [],
-    exports: selected
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
   };
+  return namedFunctions[functionName];
 }
-function omitExports(source, omit) {
-  const omitSet = new Set(omit);
-  for (const name of omit) {
-    if (!(name in source.exports)) {
-      throw new Error(`omitExports: "${source.id}" has no export "${name}".`);
+function createRawFunction(coreFn, options) {
+  const {
+    sdkContext,
+    name,
+    schema,
+    positional,
+    annotator,
+    getDeprecation,
+    getStability
+  } = options;
+  return function(rawInput) {
+    const internal = arguments[1];
+    const context = resolveCallContext(internal);
+    if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
+      signalDeprecation(sdkContext, name, getDeprecation);
+      signalStability(sdkContext, name, getStability);
     }
-  }
-  const kept = {};
-  for (const [binding, child] of Object.entries(source.exports)) {
-    if (!omitSet.has(binding)) kept[binding] = child;
-  }
-  return {
-    pluginType: "aggregate",
-    name: makeId(`omit`, source.name, "aggregate"),
-    id: `${source.id}#omit:${selectSeq++}`,
-    imports: [source],
-    importBindings: [],
-    exports: kept
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  };
-}
-
-// src/model/legacy.ts
-function fromFunctionPlugin(fn, config) {
-  logDeprecation(
-    "fromFunctionPlugin() is deprecated. Author plugins with defineMethod/definePlugin instead."
-  );
-  return {
-    pluginType: "legacy",
-    name: config.name,
-    namespace: config.namespace,
-    id: makeId(config.name, config.namespace, "aggregate"),
-    imports: [],
-    importBindings: [],
-    run: fn
-  };
-}
-function defineLegacyMerge(args) {
-  logDeprecation(
-    "defineLegacyMerge() is deprecated. Build directly with createSdk(root, { configuration }) instead."
-  );
-  return {
-    pluginType: "legacy-merge",
-    name: args.name,
-    namespace: args.namespace,
-    id: makeId(args.name, args.namespace, "aggregate"),
-    legacy: fromFunctionPlugin(args.legacy, {
-      name: args.name,
-      namespace: args.namespace
-    }),
-    plugin: args.plugin
+    return runInMethodScope(() => {
+      const startTime = Date.now();
+      const depth = Math.max(context.depth, getCurrentDepth());
+      const insideObserver = isInsideObserver();
+      const hooks = insideObserver ? void 0 : sdkContext.hooks;
+      const adaptError = resolveCoreOptions(sdkContext)?.adaptError;
+      const input = schema ? rawInput ?? {} : rawInput;
+      applyAnnotations({
+        context,
+        methodName: name,
+        input,
+        hookAnnotator: hooks?.annotator,
+        methodAnnotator: annotator
+      });
+      const record = input;
+      const args = positional ? positional.filter((key) => record?.[key] !== void 0).map((key) => record?.[key]) : [input];
+      const hookBase = {
+        methodName: name,
+        args,
+        isPaginated: false,
+        depth,
+        callId: context.callId,
+        callOrigin: context.callOrigin,
+        annotations: context.annotations
+      };
+      hooks?.onMethodStart?.({ ...hookBase });
+      const fireEnd = (error) => {
+        hooks?.onMethodEnd?.({
+          ...hookBase,
+          durationMs: Date.now() - startTime,
+          ...error ? { error } : {}
+        });
+      };
+      try {
+        const parsed = schema ? validateOptions(schema, input, { adaptError }) : input;
+        const result = coreFn(parsed, context);
+        if (isPromiseLike(result)) {
+          return result.then(
+            (value) => {
+              fireEnd();
+              return value;
+            },
+            (error) => {
+              fireEnd(
+                error instanceof Error ? error : new Error(String(error))
+              );
+              throw error;
+            }
+          );
+        }
+        fireEnd();
+        return result;
+      } catch (error) {
+        fireEnd(error instanceof Error ? error : new Error(String(error)));
+        throw error;
+      }
+    });
   };
 }
-function legacyGraphEntry(name, value, pluginMeta) {
-  const { inputSchema, ...rest } = pluginMeta ?? {};
-  const meta = Object.keys(rest).length ? rest : void 0;
-  if (typeof value === "function") {
-    return {
-      pluginType: "method",
-      name,
-      value,
-      chain: [],
-      ...inputSchema ? { inputSchema } : {},
-      ...meta ? { meta } : {}
-    };
+function isSdkPage(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const page = value;
+  if (!Array.isArray(page.data)) return false;
+  if (page.nextCursor !== void 0 && typeof page.nextCursor !== "string") {
+    return false;
   }
-  return { pluginType: "property", name, value, ...meta ? { meta } : {} };
+  return Object.keys(page).every((k) => k === "data" || k === "nextCursor");
 }
-
-// src/model/builtins.ts
-var import_zod3 = require("zod");
-
-// src/model/registry-support.ts
-function adaptLegacyFormatter(legacy, sdk) {
-  const legacyFetch = legacy.fetch;
-  return {
-    getContext: legacyFetch ? async ({ items, input, context }) => {
-      let ctx = context;
-      for (const item of items) {
-        ctx = await legacyFetch(sdk, input, item, ctx);
+function createPageFunction(coreFn, {
+  sdkContext,
+  adaptPage,
+  finalizePage
+}) {
+  const functionName = coreFn.name + "Page";
+  const namedFunctions = {
+    [functionName]: async function(options, callContext) {
+      try {
+        const response = await coreFn(options, callContext);
+        const page = adaptPage ? adaptPage(response) : response;
+        if (!isSdkPage(page)) {
+          throw new Error(
+            `${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, options) : page;
+      } catch (error) {
+        throw normalizeError(error, resolveCoreOptions(sdkContext)?.adaptError);
       }
-      return ctx;
-    } : void 0,
-    format: ({ item, context }) => legacy.format(item, context)
+    }
   };
+  return namedFunctions[functionName];
 }
-function normalizeFormatter(entry, sdk) {
-  if (entry.pluginType !== "method") return void 0;
-  if (entry.formatter) return entry.formatter;
-  const legacy = entry.meta?.formatter;
-  return legacy ? adaptLegacyFormatter(legacy, sdk) : void 0;
-}
-function normalizeResolvers(entry) {
-  if (entry.pluginType !== "method") return void 0;
-  return entry.resolvers;
-}
-function methodPositional(entry) {
-  if (entry.pluginType !== "method") return void 0;
-  return entry.positional;
-}
-function pluginEntryMeta(entry) {
-  if (entry.pluginType === "method" && entry.meta) {
-    return entry.inputSchema ? { ...entry.meta, inputSchema: entry.inputSchema } : entry.meta;
-  }
-  if (entry.pluginType === "property" && entry.meta) return entry.meta;
-  return void 0;
-}
-function foldDynamicMembers(entry, surfaceBindings, meta) {
-  if (entry.pluginType !== "property" || !entry.dynamicMembers) return;
-  for (const member of entry.dynamicMembers) {
-    if (!surfaceBindings.has(member.rootBinding)) {
-      throw new Error(
-        `dynamicMember "${member.name}": its root "${member.rootBinding}" is not a surfaced member. A dynamic member's path must start with a real binding.`
-      );
+function createPaginatedFunction(coreFn, options) {
+  const {
+    sdkContext,
+    schema,
+    name,
+    defaultPageSize,
+    adaptPage,
+    annotator,
+    finalizePage,
+    frameworkOptions,
+    getDeprecation,
+    getStability
+  } = options;
+  const pageFunction = createPageFunction(coreFn, {
+    sdkContext,
+    adaptPage,
+    finalizePage
+  });
+  const functionName = name || coreFn.name;
+  const namedFunctions = {
+    [functionName]: function(callOptions) {
+      const internal = arguments[1];
+      const context = resolveCallContext(internal);
+      if (!isCallContext(internal) && internal !== INTERNAL_CALL) {
+        signalDeprecation(sdkContext, functionName, getDeprecation);
+        signalStability(sdkContext, functionName, getStability);
+      }
+      return runInMethodScope(() => {
+        const startTime = Date.now();
+        const normalizedOptions = callOptions ?? {};
+        const args = [normalizedOptions];
+        const depth = Math.max(context.depth, getCurrentDepth());
+        const insideObserver = isInsideObserver();
+        const hooks = insideObserver ? void 0 : sdkContext.hooks;
+        const adaptError = resolveCoreOptions(sdkContext)?.adaptError;
+        applyAnnotations({
+          context,
+          methodName: functionName,
+          input: normalizedOptions,
+          hookAnnotator: hooks?.annotator,
+          methodAnnotator: annotator
+        });
+        const hookBase = {
+          methodName: functionName,
+          args,
+          isPaginated: true,
+          depth,
+          callId: context.callId,
+          callOrigin: context.callOrigin,
+          annotations: context.annotations
+        };
+        hooks?.onMethodStart?.({ ...hookBase });
+        try {
+          const validatedOptions = mergeCallOptions(
+            parseCallOptions(normalizedOptions, {
+              schema,
+              policy: frameworkOptions,
+              adaptError
+            })
+          );
+          const pageSize = validatedOptions.pageSize ?? defaultPageSize;
+          const optimizedOptions = {
+            ...validatedOptions,
+            pageSize
+          };
+          const iterator = paginate(
+            (pageOptions) => pageFunction(pageOptions, context),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            optimizedOptions
+          );
+          const firstPagePromise = iterator.next().then((result) => {
+            if (result.done) {
+              throw new Error("Paginate should always iterate at least once");
+            }
+            return result.value;
+          });
+          if (hooks?.onMethodEnd) {
+            firstPagePromise.then(
+              () => {
+                hooks.onMethodEnd({
+                  ...hookBase,
+                  durationMs: Date.now() - startTime
+                });
+              },
+              (error) => {
+                hooks.onMethodEnd({
+                  ...hookBase,
+                  durationMs: Date.now() - startTime,
+                  error: error instanceof Error ? error : new Error(String(error))
+                });
+              }
+            );
+          }
+          const pageStream = async function* () {
+            yield await firstPagePromise;
+            for await (const page of iterator) {
+              yield page;
+            }
+          }();
+          return Object.assign(firstPagePromise, {
+            [Symbol.asyncIterator]() {
+              return pageStream;
+            },
+            pages: function() {
+              return {
+                [Symbol.asyncIterator]() {
+                  return pageStream;
+                }
+              };
+            },
+            items: function() {
+              return {
+                [Symbol.asyncIterator]: async function* () {
+                  for await (const page of pageStream) {
+                    for (const item of page.data) {
+                      yield item;
+                    }
+                  }
+                }
+              };
+            }
+          });
+        } catch (error) {
+          const normalizedError = normalizeError(error, adaptError);
+          hooks?.onMethodEnd?.({
+            ...hookBase,
+            durationMs: Date.now() - startTime,
+            error: normalizedError
+          });
+          throw normalizedError;
+        }
+      });
     }
-    meta[member.name] = member.meta;
-  }
-}
-function collectSurfaceProjection(context, formatterSdk) {
-  const meta = {};
-  const entries = {};
-  for (const [binding, id] of Object.entries(context.surface)) {
-    const entry = context.plugins[id];
-    if (!entry || entry.pluginType === "aggregate") continue;
-    entries[binding] = entry;
-    const m = pluginEntryMeta(entry);
-    if (m) meta[binding] = m;
-  }
-  const surfaceBindings = new Set(Object.keys(context.surface));
-  for (const entry of Object.values(entries)) {
-    foldDynamicMembers(entry, surfaceBindings, meta);
-  }
-  const formatters = {};
-  const resolvers = {};
-  const positional = {};
-  const skipInputValidation = {};
-  for (const [binding, entry] of Object.entries(entries)) {
-    const f = normalizeFormatter(entry, formatterSdk);
-    if (f) formatters[binding] = f;
-    const r = normalizeResolvers(entry);
-    if (r) resolvers[binding] = r;
-    const p = methodPositional(entry);
-    if (p) positional[binding] = p;
-    if (entry.pluginType === "method" && entry.skipInputValidation)
-      skipInputValidation[binding] = true;
-  }
-  return { meta, formatters, 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)) {
-    const entry = context.plugins[id];
-    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,
-    ...projection,
-    packageFilter
-  });
+  };
+  return namedFunctions[functionName];
 }
 
-// src/model/builtins.ts
-var coreOptionsPluginRef = declareOptionalProperty({ id: CORE_OPTIONS_ID });
-var dangerousContextPlugin = {
-  pluginType: "property",
-  name: "context",
-  namespace: "kitcore",
-  id: "kitcore/context",
-  imports: [],
-  importBindings: [],
-  privileged: true
-};
-var getRegistryPlugin = defineMethod({
-  name: "getRegistry",
-  namespace: "kitcore",
-  imports: [dangerousContextPlugin],
-  inputSchema: import_zod3.z.object({ package: import_zod3.z.string().optional() }).optional(),
-  run: ({ imports, input }) => getCachedRegistry(imports.context, input?.package)
-});
-
 // src/utils/output-policy.ts
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -2574,6 +2288,62 @@ function applyListOutputPolicy(page, policy) {
   return next;
 }
 
+// src/model/add-plugin-transaction.ts
+function snapshotGraph({
+  context,
+  sdk,
+  surfaceKeys
+}) {
+  const ids = new Set(Object.keys(context.plugins));
+  const surface = Object.assign(
+    /* @__PURE__ */ Object.create(null),
+    context.surface
+  );
+  const propertyDescriptors = /* @__PURE__ */ new Map();
+  for (const key of surfaceKeys) {
+    propertyDescriptors.set(key, Object.getOwnPropertyDescriptor(sdk, key));
+  }
+  const hooks = context.hooks;
+  const disposerCount = context.disposers?.length ?? 0;
+  const chainLengths = /* @__PURE__ */ new Map();
+  const descriptions = /* @__PURE__ */ new Map();
+  for (const [id, entry] of Object.entries(context.plugins)) {
+    if (entry.pluginType !== "method") continue;
+    chainLengths.set(id, entry.chain.length);
+    descriptions.set(id, pickDefined(entry, METHOD_META_KEYS));
+  }
+  return () => {
+    const dropped = context.disposers?.slice(disposerCount) ?? [];
+    for (let i = dropped.length - 1; i >= 0; i--) {
+      try {
+        void Promise.resolve(dropped[i].dispose()).catch(() => {
+        });
+      } catch {
+      }
+    }
+    for (const id of Object.keys(context.plugins)) {
+      if (!ids.has(id)) delete context.plugins[id];
+    }
+    for (const [id, length] of chainLengths) {
+      const entry = context.plugins[id];
+      if (entry?.pluginType === "method") entry.chain.length = length;
+    }
+    for (const [id, description] of descriptions) {
+      const entry = context.plugins[id];
+      if (entry?.pluginType !== "method") continue;
+      for (const key of METHOD_META_KEYS) delete entry[key];
+      Object.assign(entry, description);
+    }
+    context.hooks = hooks;
+    if (context.disposers) context.disposers.length = disposerCount;
+    context.surface = surface;
+    for (const [key, descriptor] of propertyDescriptors) {
+      if (descriptor) Object.defineProperty(sdk, key, descriptor);
+      else delete sdk[key];
+    }
+  };
+}
+
 // src/model/materialize.ts
 var FRAMEWORK_CONFIGURATION_IDS = /* @__PURE__ */ new Set([
   CORE_OPTIONS_ID
@@ -2584,6 +2354,19 @@ function normalizeOutput(output) {
   return output;
 }
 function getContext(sdk) {
+  const context = tryGetContext(sdk);
+  if (!context) {
+    throw createCoreError({
+      code: CoreErrorCode.NoSdkContext,
+      message: "getContext: object has no kitcore context. Only an SDK built by createSdk carries one."
+    });
+  }
+  return context;
+}
+function tryGetContext(sdk) {
+  if (typeof sdk !== "object" && typeof sdk !== "function" || sdk === null) {
+    return void 0;
+  }
   return sdk[CONTEXT];
 }
 function assertDynamicMemberRoot(entry) {
@@ -2595,11 +2378,9 @@ function assertDynamicMemberRoot(entry) {
   );
 }
 function getRegistry(sdk, packageFilter) {
-  if (typeof sdk !== "object" && typeof sdk !== "function" || sdk === null)
-    throw createNoRegistryError();
-  const context = getContext(sdk);
+  const context = tryGetContext(sdk);
   if (context?.surface) return getCachedRegistry(context, packageFilter);
-  const surfaced = sdk.getRegistry;
+  const surfaced = sdk?.getRegistry;
   if (typeof surfaced === "function") {
     return surfaced.call(
       sdk,
@@ -2609,9 +2390,10 @@ function getRegistry(sdk, packageFilter) {
   throw createNoRegistryError();
 }
 function createNoRegistryError() {
-  return new Error(
-    "getRegistry: sdk has no kitcore context and no surfaced getRegistry()."
-  );
+  return createCoreError({
+    code: CoreErrorCode.NoSdkContext,
+    message: "getRegistry: sdk has no kitcore context and no surfaced getRegistry()."
+  });
 }
 function isResolverRef(value) {
   return "ref" in value;
@@ -2660,8 +2442,14 @@ function edgesOf(plugin) {
   }
   return plugin.imports;
 }
-function isStandIn(plugin) {
-  return (plugin.pluginType === "method" || plugin.pluginType === "property" || plugin.pluginType === "aggregate") && plugin.standIn === true;
+function sameIdError({
+  plugin,
+  existing
+}) {
+  const fix = isDefault(existing) ? `The plugin in place is the declareDefault provider for this id, and its dependents already ran setup against it. Register the explicit provider in the graph you pass to createSdk, where it preempts the default.` : plugin.pluginType === "method-override" ? `An override's id comes from the method it patches, so put one of them under its own namespace, or merge both patches into a single override.` : `Ids are the identity in this graph: give it its own id, or rebuild with createSdk to replace the original.`;
+  return new Error(
+    `addPlugin: "${plugin.id}" is already applied by a different plugin. The add would leave the first one in place and contribute nothing, so it is refused. ${fix}`
+  );
 }
 function isDefault(plugin) {
   return (plugin.pluginType === "method" || plugin.pluginType === "property") && plugin.defaultSource !== void 0;
@@ -2679,12 +2467,25 @@ function topoOrder(descriptors) {
   for (const id of descriptors.keys()) visit(id);
   return order;
 }
-function collectPlugins(root, materialized = /* @__PURE__ */ new Set(), configuration) {
+function collectPlugins({
+  root,
+  caller,
+  applied,
+  configuration
+}) {
   const rank = (plugin) => isStandIn(plugin) ? 0 : isDefault(plugin) ? 1 : 2;
   const allNodes = [];
   const seen = /* @__PURE__ */ new Set();
   const collect = (plugin) => {
-    if (materialized.has(plugin.id) || seen.has(plugin)) return;
+    assertKnownPluginType({ plugin, where: caller });
+    const existing = applied[plugin.id];
+    if (existing) {
+      if (existing.descriptor !== plugin && rank(plugin) === 2) {
+        throw sameIdError({ plugin, existing: existing.descriptor });
+      }
+      return;
+    }
+    if (seen.has(plugin)) return;
     seen.add(plugin);
     allNodes.push(plugin);
     for (const edge of edgesOf(plugin)) collect(edge);
@@ -2749,7 +2550,7 @@ function collectPlugins(root, materialized = /* @__PURE__ */ new Set(), configur
       const winnerRank = rank(winner);
       if (winnerRank === 2) {
         throw new Error(
-          `createSdk: duplicate plugin id "${id}". Two different plugins registered under the same id.`
+          `${caller}: duplicate plugin id "${id}". Two different plugins registered under the same id.`
         );
       }
       if (winnerRank === 1) {
@@ -2809,7 +2610,7 @@ function collectPlugins(root, materialized = /* @__PURE__ */ new Set(), configur
     if (isStandIn(plugin)) {
       if ("optional" in plugin && plugin.optional) continue;
       throw new Error(
-        `createSdk: missing dependency "${id}". A plugin depends on it (via a stand-in) but no implementation was registered.`
+        `${caller}: missing dependency "${id}". A plugin depends on it (via a stand-in) but no implementation was registered.`
       );
     }
   }
@@ -2817,7 +2618,7 @@ function collectPlugins(root, materialized = /* @__PURE__ */ new Set(), configur
     const winner = byId.get(id);
     if (winner && isDefault(winner)) {
       throw new Error(
-        `createSdk: conflicting defaults for "${id}". Two different plugins were declared as defaults for the same id and nothing else provides it. Register an explicit (non-default) plugin for this id to choose the winner, or give the implementations distinct ids if they are meant to coexist.`
+        `${caller}: conflicting defaults for "${id}". Two different plugins were declared as defaults for the same id and nothing else provides it. Register an explicit (non-default) plugin for this id to choose the winner, or give the implementations distinct ids if they are meant to coexist.`
       );
     }
   }
@@ -2839,7 +2640,7 @@ function bindValue({
       configurable: true
     });
   } else {
-    const value = bindMode === "internal" && entry.pluginType === "method" ? entry.bindInternal?.({ ctx, frameworkOrigin }) ?? entry.internalValue ?? entry.value : entry.value;
+    const value = bindMode === "internal" && entry.pluginType === "method" ? entry.bindInternal({ ctx, frameworkOrigin }) : entry.value;
     Object.defineProperty(target, key, {
       value,
       writable: true,
@@ -2875,10 +2676,15 @@ function buildImports({
       });
       continue;
     }
+    if (!entry) {
+      throw new Error(
+        `buildImports: no materialized plugin for "${id}", bound as "${binding}". If this surfaced from a \`dispose\`, the SDK it ran against was rolled back, so release before the first \`await\`.`
+      );
+    }
     bindValue({
       target: imports,
       key: binding,
-      entry,
+      entry: valueEntryOf(entry, id),
       bindMode: "internal",
       ctx,
       frameworkOrigin
@@ -2900,14 +2706,6 @@ function bindInternalTwin({
   }
   return internalValue;
 }
-function mirrorLegacyRootKeys(context, rootKeys, meta) {
-  const exports2 = {};
-  for (const [name, value] of Object.entries(rootKeys)) {
-    context.plugins[name] = legacyGraphEntry(name, value, meta[name]);
-    exports2[name] = value;
-  }
-  return exports2;
-}
 function recordExportSurface(context, exports2) {
   for (const [binding, child] of Object.entries(exports2)) {
     context.surface[binding] = child.id;
@@ -2915,9 +2713,8 @@ function recordExportSurface(context, exports2) {
 }
 function materialize(descriptors, context) {
   const states = /* @__PURE__ */ new Map();
-  runLegacyPass(descriptors, context);
-  buildMethodEntries(descriptors, context, states);
-  buildEagerArtifacts(descriptors, context, states);
+  buildLeafEntries(descriptors, context, states);
+  runSetup(descriptors, context, states);
   bindAttachments(descriptors, context);
   resolveAggregates(descriptors, context);
   assembleMiddleware(descriptors, context, states);
@@ -2929,22 +2726,35 @@ function applyMethodOverride(context, override) {
   const entry = context.plugins[override.target];
   if (!entry) {
     throw new Error(
-      `defineMethodOverride: no method "${override.target}" to override. Include the target method in the SDK build.`
+      `defineOverride: no method "${override.target}" to override. Include the target method in the SDK build.`
     );
   }
   if (entry.pluginType !== "method") {
     throw new Error(
-      `defineMethodOverride: "${override.target}" is a ${entry.pluginType}, not a method; only methods can be overridden.`
+      `defineOverride: "${override.target}" is a ${entry.pluginType}, not a method; only methods can be overridden.`
     );
   }
-  entry.meta = { ...entry.meta, ...override.meta };
+  Object.assign(entry, override.patch);
+}
+function addOverridePlugin(context, override) {
+  const existing = context.plugins[override.id];
+  if (existing?.descriptor === override) return;
+  if (existing) {
+    throw sameIdError({ plugin: override, existing: existing.descriptor });
+  }
+  applyMethodOverride(context, override);
+  context.plugins[override.id] = overrideEntry(override);
 }
 function applyMethodOverrides(descriptors, context) {
   for (const descriptor of descriptors.values()) {
     if (descriptor.pluginType !== "method-override") continue;
     applyMethodOverride(context, descriptor);
+    context.plugins[descriptor.id] = overrideEntry(descriptor);
   }
 }
+function overrideEntry(descriptor) {
+  return { pluginType: "method-override", name: descriptor.name, descriptor };
+}
 function bindResolver(resolver, plugins) {
   switch (resolver.type) {
     case "static":
@@ -3014,7 +2824,9 @@ function bindResolver(resolver, plugins) {
         frameworkOrigin: true
       });
       const {
-        getContext: getContext2,
+        // Named apart from the module's exported `getContext`, which throws when
+        // an object carries no kitcore context.
+        getContext: getResolverContext,
         listItems,
         validate,
         tryResolveWithoutPrompt,
@@ -3028,8 +2840,8 @@ function bindResolver(resolver, plugins) {
         prompt: resolver.prompt,
         listItems: ({ input, context, search, cursor }) => listItems({ imports, input, context, search, cursor })
       };
-      if (getContext2)
-        bound.getContext = ({ input }) => getContext2({ imports, input });
+      if (getResolverContext)
+        bound.getContext = ({ input }) => getResolverContext({ imports, input });
       if (validate) {
         bound.validate = ({ value, input, context }) => validate({ imports, value, input, context });
       }
@@ -3073,9 +2885,9 @@ function bindFormatter(formatter, plugins) {
     frameworkOrigin: true
   });
   const bound = { format: formatter.format };
-  const { getContext: getContext2 } = formatter;
-  if (getContext2)
-    bound.getContext = ({ items, input, context }) => getContext2({ imports, items, input, context });
+  const { getContext: getFormatterContext } = formatter;
+  if (getFormatterContext)
+    bound.getContext = ({ items, input, context }) => getFormatterContext({ imports, items, input, context });
   return bound;
 }
 function bindAttachments(descriptors, context) {
@@ -3096,64 +2908,35 @@ function bindAttachments(descriptors, context) {
     }
   }
 }
-function runLegacyPass(descriptors, context) {
+function buildLeafEntries(descriptors, context, states) {
   const plugins = context.plugins;
-  const compatView = new Proxy(
-    {},
-    {
-      get: (_target, prop) => {
-        if (prop === "context") return context;
-        const entry = plugins[prop];
-        return entry?.value;
+  for (const [id, descriptor] of descriptors) {
+    if (descriptor.pluginType === "property") {
+      if (!isStandIn(descriptor)) {
+        plugins[id] = buildPropertyEntry(descriptor, id, context, states);
       }
+      continue;
     }
-  );
-  for (const id of topoOrder(descriptors)) {
-    const descriptor = descriptors.get(id);
-    if (!descriptor || descriptor.pluginType !== "legacy") continue;
-    const { rootKeys, meta, hooks, contextRest } = splitPluginContribution(
-      descriptor.run(compatView)
-    );
-    Object.assign(context.meta, meta);
-    Object.assign(context, contextRest);
-    context.hooks = buildHooks(context.hooks, hooks);
-    const exports2 = mirrorLegacyRootKeys(context, rootKeys, meta);
-    for (const name of Object.keys(rootKeys)) context.surface[name] = name;
-    if (!("getRegistry" in exports2)) {
-      let getRegistry3 = function(options) {
-        return getCachedRegistry(context, options?.package);
-      };
-      var getRegistry2 = getRegistry3;
-      exports2.getRegistry = getRegistry3;
-      plugins.getRegistry = {
-        pluginType: "method",
-        name: "getRegistry",
-        value: getRegistry3,
-        chain: []
-      };
-    }
-    plugins[id] = { pluginType: "aggregate", name: descriptor.name, exports: exports2 };
-  }
-}
-function buildMethodEntries(descriptors, context, states) {
-  const plugins = context.plugins;
-  for (const [id, descriptor] of descriptors) {
     if (descriptor.pluginType !== "method") continue;
     if (isStandIn(descriptor)) continue;
     const out = normalizeOutput(descriptor.output);
     const entry = {
       pluginType: "method",
       name: descriptor.name,
+      descriptor,
       chain: [],
+      ...pickDefined(descriptor, METHOD_META_KEYS),
       inputSchema: descriptor.inputSchema,
       skipInputValidation: descriptor.skipInputValidation,
-      // Derive the presentation type from the output mode when the author did
-      // not set one; an explicit meta.type (e.g. "create") still wins.
-      meta: out.type === "raw" || descriptor.meta?.type ? descriptor.meta : { ...descriptor.meta, type: out.type },
+      outputSchema: descriptor.outputSchema,
       output: out,
-      // Replaced below; never called.
-      value: () => void 0
+      // All three are replaced below, once the boundary they wrap exists; never
+      // called in this placeholder form.
+      value: () => void 0,
+      internalValue: () => void 0,
+      bindInternal: () => () => void 0
     };
+    if (entry.type === void 0 && out.type !== "raw") entry.type = out.type;
     const callRun = (input, ctx) => {
       const callContext = ctx ?? rootCallContext();
       return descriptor.run({
@@ -3189,13 +2972,12 @@ function buildMethodEntries(descriptors, context, states) {
       }
       return next(input);
     };
-    const sdk = { context };
     const methodAnnotator = descriptor.annotator;
     const boundAnnotator = methodAnnotator ? (input) => methodAnnotator({ input }) : void 0;
     const outputPolicy = (callOptions) => {
       const core = resolveCoreOptions(context);
       return {
-        outputSchema: descriptor.meta?.outputSchema,
+        outputSchema: descriptor.outputSchema,
         skipOutputValidation: descriptor.skipOutputValidation,
         skippedByCaller: readSkipOutputDataValidation(callOptions),
         includeOutputValidationDroppedPaths: core?.includeOutputValidationDroppedPaths,
@@ -3211,7 +2993,7 @@ function buildMethodEntries(descriptors, context, states) {
           (input, ctx) => callRun(stripFrameworkOnlyOptions(input, withheld), ctx)
         ),
         {
-          sdk,
+          sdkContext: context,
           schema: descriptor.inputSchema,
           name: descriptor.name,
           frameworkOptions,
@@ -3222,8 +3004,8 @@ function buildMethodEntries(descriptors, context, states) {
           // (item mode's sibling); dropped paths surface as `[].x` in the page's
           // `meta`, unioned across items.
           finalizePage: (page, callOptions) => applyListOutputPolicy(page, outputPolicy(callOptions)),
-          getDeprecation: () => entry.meta?.deprecation,
-          getStability: () => entry.meta ? normalizeStability(entry.meta) : void 0
+          getDeprecation: () => entry.deprecation,
+          getStability: () => normalizeStability(entry)
         }
       );
     } else if (out.type === "item") {
@@ -3234,17 +3016,17 @@ function buildMethodEntries(descriptors, context, states) {
       entry.value = createFunction(
         fold(itemCore),
         {
-          sdk,
+          sdkContext: context,
           schema: descriptor.inputSchema,
           name: descriptor.name,
           frameworkOptions,
           annotator: boundAnnotator,
-          getDeprecation: () => entry.meta?.deprecation,
-          getStability: () => entry.meta ? normalizeStability(entry.meta) : void 0
+          getDeprecation: () => entry.deprecation,
+          getStability: () => normalizeStability(entry)
         }
       );
     } else {
-      const rawValidates = descriptor.meta?.outputSchema !== void 0 && !descriptor.skipOutputValidation;
+      const rawValidates = descriptor.outputSchema !== void 0 && !descriptor.skipOutputValidation;
       const validateRaw = (out2) => {
         const policy = outputPolicy(void 0);
         if (isPromiseLike(out2)) {
@@ -3260,7 +3042,7 @@ function buildMethodEntries(descriptors, context, states) {
           return rawValidates ? validateRaw(out2) : out2;
         },
         {
-          sdk,
+          sdkContext: context,
           name: descriptor.name,
           schema: descriptor.skipInputValidation ? void 0 : descriptor.inputSchema,
           positional: descriptor.positional,
@@ -3268,9 +3050,9 @@ function buildMethodEntries(descriptors, context, states) {
           // The boundary reads the deprecation LIVE off the entry, so a
           // deprecation merged after build (defineMethodOverride, addPlugin)
           // fires too. Same for the stability level, normalized from the
-          // entry meta (declared level or legacy `experimental` boolean).
-          getDeprecation: () => entry.meta?.deprecation,
-          getStability: () => entry.meta ? normalizeStability(entry.meta) : void 0
+          // descriptor, with an override's patch on top.
+          getDeprecation: () => entry.deprecation,
+          getStability: () => normalizeStability(entry)
         }
       );
     }
@@ -3289,8 +3071,8 @@ function buildMethodEntries(descriptors, context, states) {
       entry.internalValue = internalValue;
       entry.bindInternal = (opts) => bindInternalTwin({
         ...opts,
-        withContext: (context2) => {
-          return (...args) => canonicalValue(pack(args), context2);
+        withContext: (ctx) => {
+          return (...args) => canonicalValue(pack(args), ctx);
         },
         internalValue
       });
@@ -3300,29 +3082,53 @@ function buildMethodEntries(descriptors, context, states) {
       entry.internalValue = internalValue;
       entry.bindInternal = (opts) => bindInternalTwin({
         ...opts,
-        withContext: (context2) => (input) => canonicalValue(input, context2),
+        withContext: (ctx) => (input) => canonicalValue(input, ctx),
         internalValue
       });
     }
     plugins[id] = entry;
   }
 }
-function buildEagerArtifacts(descriptors, context, states) {
+function buildPropertyEntry(descriptor, id, context, states) {
+  const plugins = context.plugins;
+  const base = {
+    pluginType: "property",
+    name: descriptor.name,
+    descriptor,
+    ...pickDefined(descriptor, PROPERTY_META_KEYS),
+    dynamicMembers: descriptor.dynamicMembers
+  };
+  if (descriptor.privileged) return { ...base, value: context };
+  if (descriptor.get) {
+    const get = descriptor.get;
+    const importBindings = descriptor.importBindings;
+    return {
+      ...base,
+      getValue: (callContext) => get({
+        imports: buildImports({ plugins, importBindings, ctx: callContext }),
+        state: states.get(id),
+        callContext
+      })
+    };
+  }
+  return { ...base, value: descriptor.value };
+}
+function runSetup(descriptors, context, states) {
   const plugins = context.plugins;
-  const built = /* @__PURE__ */ new Set();
-  const building = /* @__PURE__ */ new Set();
-  const ensureBuilt = (id) => {
-    if (built.has(id)) return;
+  const done = /* @__PURE__ */ new Set();
+  const running = /* @__PURE__ */ new Set();
+  const ensureSetup = (id) => {
+    if (done.has(id)) return;
     const descriptor = descriptors.get(id);
-    if (!descriptor || descriptor.pluginType === "aggregate" || descriptor.pluginType === "legacy" || descriptor.pluginType === "method-override" || isStandIn(descriptor)) {
-      built.add(id);
+    if (!descriptor || descriptor.pluginType === "aggregate" || descriptor.pluginType === "method-override" || isStandIn(descriptor)) {
+      done.add(id);
       return;
     }
-    if (building.has(id)) {
+    if (running.has(id)) {
       throw new Error(`createSdk: dependency cycle at "${id}".`);
     }
-    building.add(id);
-    for (const { id: depId } of descriptor.importBindings) ensureBuilt(depId);
+    running.add(id);
+    for (const { id: depId } of descriptor.importBindings) ensureSetup(depId);
     const recordDisposer = () => {
       const dispose = descriptor.dispose;
       if (!dispose) return;
@@ -3341,83 +3147,23 @@ function buildEagerArtifacts(descriptors, context, states) {
         })
       });
     };
-    if (descriptor.pluginType === "hook") {
-      states.set(
-        id,
-        descriptor.setup ? descriptor.setup({
-          imports: buildImports({
-            plugins,
-            importBindings: descriptor.importBindings
-          })
-        }) : void 0
-      );
-      recordDisposer();
-      building.delete(id);
-      built.add(id);
-      return;
-    }
-    if (descriptor.pluginType === "method") {
-      states.set(
-        id,
-        descriptor.setup ? descriptor.setup({
-          imports: buildImports({
-            plugins,
-            importBindings: descriptor.importBindings
-          })
-        }) : void 0
-      );
-    } else {
-      states.set(
-        id,
-        descriptor.setup ? descriptor.setup({
-          imports: buildImports({
-            plugins,
-            importBindings: descriptor.importBindings
-          })
-        }) : void 0
-      );
-      if (descriptor.privileged) {
-        plugins[id] = {
-          pluginType: "property",
-          name: descriptor.name,
-          value: context,
-          meta: descriptor.meta,
-          dynamicMembers: descriptor.dynamicMembers
-        };
-      } else if (descriptor.get) {
-        const get = descriptor.get;
-        const importBindings = descriptor.importBindings;
-        plugins[id] = {
-          pluginType: "property",
-          name: descriptor.name,
-          getValue: (callContext) => get({
-            imports: buildImports({
-              plugins,
-              importBindings,
-              ctx: callContext
-            }),
-            state: states.get(id),
-            callContext
-          }),
-          meta: descriptor.meta,
-          dynamicMembers: descriptor.dynamicMembers
-        };
-      } else {
-        plugins[id] = {
-          pluginType: "property",
-          name: descriptor.name,
-          value: descriptor.value,
-          meta: descriptor.meta,
-          dynamicMembers: descriptor.dynamicMembers
-        };
-      }
+    states.set(
+      id,
+      descriptor.setup?.({
+        imports: buildImports({
+          plugins,
+          importBindings: descriptor.importBindings
+        })
+      })
+    );
+    recordDisposer();
+    if (descriptor.pluginType === "property") {
       assertDynamicMemberRoot(plugins[id]);
     }
-    recordDisposer();
-    building.delete(id);
-    built.add(id);
+    running.delete(id);
+    done.add(id);
   };
-  for (const id of descriptors.keys()) ensureBuilt(id);
+  for (const id of descriptors.keys()) ensureSetup(id);
 }
 function resolvePlugin(sdk, ref) {
   const entry = getContext(sdk).plugins[ref.id];
@@ -3432,11 +3178,26 @@ function resolvePlugin(sdk, ref) {
   if (entry.pluginType === "property" && entry.getValue) {
     return entry.getValue();
   }
-  if (entry.pluginType === "method" && entry.internalValue) {
-    return entry.bindInternal?.({ frameworkOrigin: true }) ?? entry.internalValue;
+  if (entry.pluginType === "method") {
+    return entry.bindInternal({
+      frameworkOrigin: true
+    });
+  }
+  if (entry.pluginType === "hook" || entry.pluginType === "method-override") {
+    throw new Error(
+      `resolvePlugin: "${ref.id}" is a ${entry.pluginType}, which has no value to resolve. Resolve a method or property.`
+    );
   }
   return entry.value;
 }
+function valueEntryOf(entry, id) {
+  if (entry.pluginType === "hook" || entry.pluginType === "method-override") {
+    throw new Error(
+      `"${id}" is a ${entry.pluginType} and has no value to bind.`
+    );
+  }
+  return entry;
+}
 var CoreDisposeError = class extends Error {
   constructor(errors) {
     super(`disposeSdk: ${errors.length} dispose callback(s) failed.`);
@@ -3468,9 +3229,20 @@ function resolveAggregates(descriptors, context) {
     if (descriptor.pluginType !== "aggregate") continue;
     const exports2 = {};
     for (const [binding, child] of Object.entries(descriptor.exports)) {
-      bindValue({ target: exports2, key: binding, entry: plugins[child.id] });
+      const entry = plugins[child.id];
+      if (!entry || entry.pluginType === "hook" || entry.pluginType === "method-override") {
+        throw new Error(
+          `createSdk: export "${binding}" resolves to "${child.id}", which has no value. A defineHook or defineOverride belongs in \`imports\`, not \`exports\`: neither surfaces a value.`
+        );
+      }
+      bindValue({ target: exports2, key: binding, entry });
     }
-    plugins[id] = { pluginType: "aggregate", name: descriptor.name, exports: exports2 };
+    plugins[id] = {
+      pluginType: "aggregate",
+      name: descriptor.name,
+      descriptor,
+      exports: exports2
+    };
   }
 }
 function assembleMiddleware(descriptors, context, states) {
@@ -3511,9 +3283,9 @@ function assembleHooks(descriptors, context, states) {
   const plugins = context.plugins;
   for (const id of topoOrder(descriptors)) {
     const descriptor = descriptors.get(id);
-    if (!descriptor || descriptor.pluginType !== "hook" || !descriptor.observe && !descriptor.annotator) {
-      continue;
-    }
+    if (!descriptor || descriptor.pluginType !== "hook") continue;
+    plugins[id] = { pluginType: "hook", name: descriptor.name, descriptor };
+    if (!descriptor.observe && !descriptor.annotator) continue;
     const { observe, annotator } = descriptor;
     const state = states.get(id);
     const contributed = {};
@@ -3550,55 +3322,34 @@ function assembleHooks(descriptors, context, states) {
   }
 }
 function createSdk(root, options) {
+  assertPluginArgument(root, { caller: "createSdk", asRoot: true });
+  assertNotReservedKeys({
+    keys: root.pluginType === "aggregate" ? Object.keys(root.exports) : [root.name],
+    caller: "createSdk"
+  });
   const context = {
-    plugins: {},
-    meta: {},
+    plugins: /* @__PURE__ */ Object.create(null),
     hooks: {},
-    surface: {},
+    surface: /* @__PURE__ */ Object.create(null),
     disposers: []
   };
-  if (root.pluginType === "legacy-merge") {
-    const { legacy, plugin } = root;
-    const collectRoot = {
-      pluginType: "aggregate",
-      name: root.name,
-      id: `${root.id}:merge`,
-      imports: [legacy, plugin],
-      importBindings: [],
-      exports: {}
-    };
-    const plugins2 = materialize(
-      collectPlugins(collectRoot, void 0, options?.configuration),
-      context
-    );
-    const legacyExports = plugins2[legacy.id].exports;
-    let pluginSurface;
-    if (plugin.pluginType === "aggregate") {
-      pluginSurface = plugins2[plugin.id].exports;
-    } else {
-      pluginSurface = {};
-      bindValue({
-        target: pluginSurface,
-        key: plugin.name,
-        entry: plugins2[plugin.id]
-      });
-    }
-    for (const key of Object.keys(legacyExports)) context.surface[key] = key;
-    if (plugin.pluginType === "aggregate") {
-      recordExportSurface(context, plugin.exports);
-    } else {
-      context.surface[plugin.name] = plugin.id;
-    }
-    return buildSurface(context, legacyExports, pluginSurface);
-  }
   const plugins = materialize(
-    collectPlugins(root, void 0, options?.configuration),
+    collectPlugins({
+      root,
+      caller: "createSdk",
+      applied: context.plugins,
+      configuration: options?.configuration
+    }),
     context
   );
   if (root.pluginType === "method" || root.pluginType === "property") {
     context.surface[root.name] = root.id;
     const sdk = buildSurface(context);
-    bindValue({ target: sdk, key: root.name, entry: plugins[root.id] });
+    bindValue({
+      target: sdk,
+      key: root.name,
+      entry: valueEntryOf(plugins[root.id], root.id)
+    });
     return sdk;
   }
   if (root.pluginType === "aggregate")
@@ -3609,54 +3360,67 @@ function addModelPlugin(sdk, plugin, options = {}) {
   const override = options.override === true;
   const context = getContext(sdk);
   const surfaceKeys = plugin.pluginType === "aggregate" ? Object.keys(plugin.exports) : plugin.pluginType === "hook" ? [] : [plugin.name];
-  checkRootKeyCollisions(sdk, surfaceKeys, override, "addPlugin");
-  const materialized = new Set(Object.keys(context.plugins));
-  if (override && materialized.has(plugin.id)) {
+  checkRootKeyCollisions({
+    target: sdk,
+    keys: surfaceKeys,
+    override,
+    caller: "addPlugin"
+  });
+  if (override && surfaceKeys.length > 0 && plugin.id in context.plugins) {
     throw new Error(
-      `addPlugin: cannot override already-materialized plugin "${plugin.id}" on the incremental path. Rebuild the SDK with the replacement via createSdk.`
+      `addPlugin: cannot override plugin "${plugin.id}", which is already applied to this SDK, on the incremental path. Rebuild the SDK with the replacement via createSdk.`
     );
   }
-  materialize(collectPlugins(plugin, materialized), context);
-  if (plugin.pluginType === "hook") return;
-  const entry = context.plugins[plugin.id];
-  if (entry.pluginType === "aggregate") {
-    Object.defineProperties(
-      sdk,
-      Object.getOwnPropertyDescriptors(entry.exports)
+  const undo = snapshotGraph({ context, sdk, surfaceKeys });
+  try {
+    materialize(
+      collectPlugins({
+        root: plugin,
+        caller: "addPlugin",
+        applied: context.plugins
+      }),
+      context
     );
-    for (const [binding, child] of Object.entries(
-      plugin.exports
-    )) {
-      context.surface[binding] = child.id;
+    if (plugin.pluginType === "hook") return;
+    const entry = valueEntryOf(context.plugins[plugin.id], plugin.id);
+    if (entry.pluginType === "aggregate") {
+      Object.defineProperties(
+        sdk,
+        Object.getOwnPropertyDescriptors(entry.exports)
+      );
+      for (const [binding, child] of Object.entries(
+        plugin.exports
+      )) {
+        context.surface[binding] = child.id;
+      }
+    } else {
+      bindValue({ target: sdk, key: plugin.name, entry });
+      context.surface[plugin.name] = plugin.id;
     }
-  } else {
-    bindValue({ target: sdk, key: plugin.name, entry });
-    context.surface[plugin.name] = plugin.id;
+  } catch (cause) {
+    try {
+      undo();
+    } catch (rollbackFailure) {
+      const original = cause;
+      if (original && typeof original === "object" && original.cause === void 0) {
+        original.cause = rollbackFailure;
+      }
+    }
+    throw cause;
   }
 }
 function addPlugin(sdk, plugin, options) {
   const record = sdk;
+  assertPluginArgument(plugin, { caller: "addPlugin", asRoot: false });
   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);
+    if (plugin.pluginType === "method-override") {
+      addOverridePlugin(context, plugin);
     } else {
       addModelPlugin(record, plugin, options ?? {});
     }
   } finally {
-    if (context) invalidateRegistryCache(context);
+    invalidateRegistryCache(context);
   }
 }
 
@@ -4905,18 +4669,6 @@ function createController(sdk) {
   return { resolve, start: start2, step: step2, listMethods, getMethod, listChoices };
 }
 
-// src/utils/core-plugin.ts
-function createCorePlugin(options) {
-  logDeprecation(
-    "createCorePlugin() is deprecated. Inject the options under CORE_OPTIONS_ID via createSdk's configuration instead."
-  );
-  return () => ({
-    context: {
-      core: options
-    }
-  });
-}
-
 // src/transport/attempt-http-request.ts
 var import_zod10 = require("zod");
 
@@ -5352,20 +5104,13 @@ var resolveConnectionPlugin = defineMethod({
   attemptHttpRequestPlugin,
   authorizeHttpRequestPlugin,
   canonicalInputSchema,
-  composePlugins,
   concatLists,
   concatPaginated,
   coreOptionsPluginRef,
   createAsyncContext,
   createController,
   createCoreError,
-  createCorePlugin,
   createDeprecationLogger,
-  createFunction,
-  createPaginatedFunction,
-  createPaginatedPluginMethod,
-  createPluginMethod,
-  createPluginStack,
   createPrefixedCursor,
   createSdk,
   createStabilityNoticeLogger,
@@ -5382,7 +5127,6 @@ var resolveConnectionPlugin = defineMethod({
   defaultLogDeprecation,
   defineFormatter,
   defineHook,
-  defineLegacyMerge,
   defineMethod,
   defineMethodOverride,
   defineOverride,
@@ -5392,7 +5136,6 @@ var resolveConnectionPlugin = defineMethod({
   dispatchHttpRequestPlugin,
   disposeSdk,
   fetchPlugin,
-  fromFunctionPlugin,
   getContext,
   getCoreErrorCause,
   getCoreErrorCode,