@adcp/sdk 17.0.0-beta.1 → 17.0.0-beta.2

package/dist/lib/validation/schema-diagnostic-origins.d.mts

@@ -0,0 +1,21 @@
+interface SchemaEnvironment {
+    schema: unknown;
+    root: {
+        schema: unknown;
+    };
+    baseId?: string;
+}
+export interface SchemaDiagnosticOrigin {
+    schema: unknown;
+    schemaId?: string;
+    /** Original AJV function-relative spelling; exact origins remain internal. */
+    schemaPath: string;
+}
+export interface SchemaDiagnosticOrigins {
+    process: (source: string, environment?: SchemaEnvironment) => string;
+    resolve: (schemaPath: string) => unknown;
+    origin: (schemaPath: string) => SchemaDiagnosticOrigin | undefined;
+}
+/** Use AJV's supported code.process hook; only diagnostic string literals change. */
+export declare function createSchemaDiagnosticOrigins(): SchemaDiagnosticOrigins;
+export {};

package/dist/lib/validation/schema-diagnostic-origins.d.ts

@@ -0,0 +1,21 @@
+interface SchemaEnvironment {
+    schema: unknown;
+    root: {
+        schema: unknown;
+    };
+    baseId?: string;
+}
+export interface SchemaDiagnosticOrigin {
+    schema: unknown;
+    schemaId?: string;
+    /** Original AJV function-relative spelling; exact origins remain internal. */
+    schemaPath: string;
+}
+export interface SchemaDiagnosticOrigins {
+    process: (source: string, environment?: SchemaEnvironment) => string;
+    resolve: (schemaPath: string) => unknown;
+    origin: (schemaPath: string) => SchemaDiagnosticOrigin | undefined;
+}
+/** Use AJV's supported code.process hook; only diagnostic string literals change. */
+export declare function createSchemaDiagnosticOrigins(): SchemaDiagnosticOrigins;
+export {};

package/dist/lib/validation/schema-diagnostic-origins.js

@@ -0,0 +1,193 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_diagnostic_origins_exports = {};
+__export(schema_diagnostic_origins_exports, {
+  createSchemaDiagnosticOrigins: () => createSchemaDiagnosticOrigins
+});
+module.exports = __toCommonJS(schema_diagnostic_origins_exports);
+function object(value) {
+  return value !== null && typeof value === "object";
+}
+function schemaPathLiterals(source) {
+  const paths = [];
+  const stringEnd = (start) => {
+    const quote = source[start];
+    for (let index = start + 1; index < source.length; index++) {
+      if (source[index] === "\\") index++;
+      else if (source[index] === quote) return index + 1;
+    }
+    return -1;
+  };
+  for (let index = 0; index < source.length; ) {
+    const start = index;
+    let key;
+    if (source[index] === '"' || source[index] === "'") {
+      index = stringEnd(index);
+      if (index < 0) return void 0;
+      try {
+        key = JSON.parse(source.slice(start, index));
+      } catch {
+      }
+    } else if (/[A-Za-z_$]/.test(source[index])) {
+      while (index < source.length && /[\w$]/.test(source[index])) index++;
+      key = source.slice(start, index);
+    } else if (source.startsWith("//", index)) {
+      index = source.indexOf("\n", index + 2);
+      if (index < 0) break;
+    } else if (source.startsWith("/*", index)) {
+      index = source.indexOf("*/", index + 2);
+      if (index < 0) return void 0;
+      index += 2;
+    } else {
+      if (source[index] === "`") return void 0;
+      if (source[index] === "/") {
+        const pointerEscape = source.startsWith("/~/g", index) ? "/~/g" : source.startsWith("/\\//g", index) ? "/\\//g" : void 0;
+        if (pointerEscape && /\.replace\(\s*$/.test(source.slice(0, index))) {
+          index += pointerEscape.length;
+          continue;
+        }
+        const previous = source.slice(0, index).match(/(?:^|[^\w$])(data\d*)\s*$/);
+        if (!previous) return void 0;
+      }
+      index++;
+    }
+    if (key !== "schemaPath") continue;
+    let valueStart = index;
+    while (/\s/.test(source[valueStart] ?? "") && valueStart < source.length) valueStart++;
+    if (source[valueStart] !== ":") continue;
+    valueStart++;
+    while (/\s/.test(source[valueStart] ?? "") && valueStart < source.length) valueStart++;
+    if (source[valueStart] !== '"') return void 0;
+    const end = stringEnd(valueStart);
+    if (end < 0) return void 0;
+    let value;
+    try {
+      value = JSON.parse(source.slice(valueStart, end));
+    } catch {
+      return void 0;
+    }
+    if (typeof value !== "string" || !value.startsWith("#")) return void 0;
+    paths.push({ start: valueStart, end, value });
+    index = end;
+  }
+  return paths;
+}
+function createSchemaDiagnosticOrigins() {
+  const indexes = /* @__PURE__ */ new WeakMap();
+  const anonymousIds = /* @__PURE__ */ new WeakMap();
+  const origins = /* @__PURE__ */ new Map();
+  let anonymousId = 0;
+  const indexRoot = (root) => {
+    const cached = indexes.get(root);
+    if (cached) return cached;
+    const paths = /* @__PURE__ */ new WeakMap();
+    const pending = [[root, "#"]];
+    while (pending.length) {
+      const [node, pointer] = pending.pop();
+      if (paths.has(node)) continue;
+      paths.set(node, pointer);
+      for (const [key, child] of Object.entries(node)) {
+        if (object(child))
+          pending.push([child, `${pointer}/${encodeURIComponent(key.replace(/~/g, "~0").replace(/\//g, "~1"))}`]);
+      }
+    }
+    indexes.set(root, paths);
+    return paths;
+  };
+  const origin = (schemaPath) => {
+    const hash = schemaPath.indexOf("#");
+    if (hash < 0) return void 0;
+    let prefix = schemaPath;
+    while (prefix.length >= hash + 1) {
+      if (origins.has(prefix)) {
+        const entry = origins.get(prefix);
+        if (!entry) return void 0;
+        let cursor = entry.schema;
+        let schemaId = entry.schemaId;
+        const relative = schemaPath.slice(prefix.length);
+        if (relative)
+          for (const segment of relative.slice(1).split("/")) {
+            let key;
+            try {
+              key = decodeURIComponent(segment).replace(/~1/g, "/").replace(/~0/g, "~");
+            } catch {
+              return void 0;
+            }
+            if (key === "__proto__" || key === "constructor" || key === "prototype" || !object(cursor) || !Object.hasOwn(cursor, key))
+              return void 0;
+            cursor = cursor[key];
+            if (object(cursor) && typeof cursor.$id === "string") {
+              try {
+                schemaId = new URL(cursor.$id, schemaId).href;
+              } catch {
+                schemaId = cursor.$id;
+              }
+            }
+          }
+        return { schema: cursor, ...schemaId && { schemaId }, schemaPath: `#${relative}` };
+      }
+      const slash = prefix.lastIndexOf("/");
+      if (slash <= hash) {
+        if (prefix.length === hash + 1) break;
+        prefix = prefix.slice(0, hash + 1);
+      } else prefix = prefix.slice(0, slash);
+    }
+    return void 0;
+  };
+  return {
+    process(source, environment) {
+      const literals = schemaPathLiterals(source);
+      if (!environment || !literals?.length || !object(environment.schema) || !object(environment.root.schema))
+        return source;
+      const root = environment.root.schema;
+      const pointer = indexRoot(root).get(environment.schema);
+      const document = pointer !== void 0 ? root : environment.schema;
+      let id = typeof document.$id === "string" ? document.$id.replace(/#.*$/, "") : void 0;
+      if (!id) {
+        id = anonymousIds.get(document);
+        if (!id) {
+          id = `urn:adcp:schema-origin:${anonymousId++}`;
+          anonymousIds.set(document, id);
+        }
+      }
+      const prefix = `${id}${pointer ?? "#"}`;
+      if (origins.has(prefix) && origins.get(prefix)?.schema !== environment.schema) origins.set(prefix, void 0);
+      else if (!origins.has(prefix)) {
+        const schemaId = environment.baseId || (typeof environment.schema.$id === "string" ? environment.schema.$id : void 0);
+        origins.set(prefix, { schema: environment.schema, ...schemaId && { schemaId } });
+      }
+      const fragments = [];
+      let cursor = 0;
+      for (const literal of literals) {
+        fragments.push(source.slice(cursor, literal.start), JSON.stringify(prefix + literal.value.slice(1)));
+        cursor = literal.end;
+      }
+      fragments.push(source.slice(cursor));
+      return fragments.join("");
+    },
+    resolve(schemaPath) {
+      return origin(schemaPath)?.schema;
+    },
+    origin
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSchemaDiagnosticOrigins
+});

package/dist/lib/validation/schema-diagnostic-origins.mjs

@@ -0,0 +1,169 @@
+function object(value) {
+  return value !== null && typeof value === "object";
+}
+function schemaPathLiterals(source) {
+  const paths = [];
+  const stringEnd = (start) => {
+    const quote = source[start];
+    for (let index = start + 1; index < source.length; index++) {
+      if (source[index] === "\\") index++;
+      else if (source[index] === quote) return index + 1;
+    }
+    return -1;
+  };
+  for (let index = 0; index < source.length; ) {
+    const start = index;
+    let key;
+    if (source[index] === '"' || source[index] === "'") {
+      index = stringEnd(index);
+      if (index < 0) return void 0;
+      try {
+        key = JSON.parse(source.slice(start, index));
+      } catch {
+      }
+    } else if (/[A-Za-z_$]/.test(source[index])) {
+      while (index < source.length && /[\w$]/.test(source[index])) index++;
+      key = source.slice(start, index);
+    } else if (source.startsWith("//", index)) {
+      index = source.indexOf("\n", index + 2);
+      if (index < 0) break;
+    } else if (source.startsWith("/*", index)) {
+      index = source.indexOf("*/", index + 2);
+      if (index < 0) return void 0;
+      index += 2;
+    } else {
+      if (source[index] === "`") return void 0;
+      if (source[index] === "/") {
+        const pointerEscape = source.startsWith("/~/g", index) ? "/~/g" : source.startsWith("/\\//g", index) ? "/\\//g" : void 0;
+        if (pointerEscape && /\.replace\(\s*$/.test(source.slice(0, index))) {
+          index += pointerEscape.length;
+          continue;
+        }
+        const previous = source.slice(0, index).match(/(?:^|[^\w$])(data\d*)\s*$/);
+        if (!previous) return void 0;
+      }
+      index++;
+    }
+    if (key !== "schemaPath") continue;
+    let valueStart = index;
+    while (/\s/.test(source[valueStart] ?? "") && valueStart < source.length) valueStart++;
+    if (source[valueStart] !== ":") continue;
+    valueStart++;
+    while (/\s/.test(source[valueStart] ?? "") && valueStart < source.length) valueStart++;
+    if (source[valueStart] !== '"') return void 0;
+    const end = stringEnd(valueStart);
+    if (end < 0) return void 0;
+    let value;
+    try {
+      value = JSON.parse(source.slice(valueStart, end));
+    } catch {
+      return void 0;
+    }
+    if (typeof value !== "string" || !value.startsWith("#")) return void 0;
+    paths.push({ start: valueStart, end, value });
+    index = end;
+  }
+  return paths;
+}
+function createSchemaDiagnosticOrigins() {
+  const indexes = /* @__PURE__ */ new WeakMap();
+  const anonymousIds = /* @__PURE__ */ new WeakMap();
+  const origins = /* @__PURE__ */ new Map();
+  let anonymousId = 0;
+  const indexRoot = (root) => {
+    const cached = indexes.get(root);
+    if (cached) return cached;
+    const paths = /* @__PURE__ */ new WeakMap();
+    const pending = [[root, "#"]];
+    while (pending.length) {
+      const [node, pointer] = pending.pop();
+      if (paths.has(node)) continue;
+      paths.set(node, pointer);
+      for (const [key, child] of Object.entries(node)) {
+        if (object(child))
+          pending.push([child, `${pointer}/${encodeURIComponent(key.replace(/~/g, "~0").replace(/\//g, "~1"))}`]);
+      }
+    }
+    indexes.set(root, paths);
+    return paths;
+  };
+  const origin = (schemaPath) => {
+    const hash = schemaPath.indexOf("#");
+    if (hash < 0) return void 0;
+    let prefix = schemaPath;
+    while (prefix.length >= hash + 1) {
+      if (origins.has(prefix)) {
+        const entry = origins.get(prefix);
+        if (!entry) return void 0;
+        let cursor = entry.schema;
+        let schemaId = entry.schemaId;
+        const relative = schemaPath.slice(prefix.length);
+        if (relative)
+          for (const segment of relative.slice(1).split("/")) {
+            let key;
+            try {
+              key = decodeURIComponent(segment).replace(/~1/g, "/").replace(/~0/g, "~");
+            } catch {
+              return void 0;
+            }
+            if (key === "__proto__" || key === "constructor" || key === "prototype" || !object(cursor) || !Object.hasOwn(cursor, key))
+              return void 0;
+            cursor = cursor[key];
+            if (object(cursor) && typeof cursor.$id === "string") {
+              try {
+                schemaId = new URL(cursor.$id, schemaId).href;
+              } catch {
+                schemaId = cursor.$id;
+              }
+            }
+          }
+        return { schema: cursor, ...schemaId && { schemaId }, schemaPath: `#${relative}` };
+      }
+      const slash = prefix.lastIndexOf("/");
+      if (slash <= hash) {
+        if (prefix.length === hash + 1) break;
+        prefix = prefix.slice(0, hash + 1);
+      } else prefix = prefix.slice(0, slash);
+    }
+    return void 0;
+  };
+  return {
+    process(source, environment) {
+      const literals = schemaPathLiterals(source);
+      if (!environment || !literals?.length || !object(environment.schema) || !object(environment.root.schema))
+        return source;
+      const root = environment.root.schema;
+      const pointer = indexRoot(root).get(environment.schema);
+      const document = pointer !== void 0 ? root : environment.schema;
+      let id = typeof document.$id === "string" ? document.$id.replace(/#.*$/, "") : void 0;
+      if (!id) {
+        id = anonymousIds.get(document);
+        if (!id) {
+          id = `urn:adcp:schema-origin:${anonymousId++}`;
+          anonymousIds.set(document, id);
+        }
+      }
+      const prefix = `${id}${pointer ?? "#"}`;
+      if (origins.has(prefix) && origins.get(prefix)?.schema !== environment.schema) origins.set(prefix, void 0);
+      else if (!origins.has(prefix)) {
+        const schemaId = environment.baseId || (typeof environment.schema.$id === "string" ? environment.schema.$id : void 0);
+        origins.set(prefix, { schema: environment.schema, ...schemaId && { schemaId } });
+      }
+      const fragments = [];
+      let cursor = 0;
+      for (const literal of literals) {
+        fragments.push(source.slice(cursor, literal.start), JSON.stringify(prefix + literal.value.slice(1)));
+        cursor = literal.end;
+      }
+      fragments.push(source.slice(cursor));
+      return fragments.join("");
+    },
+    resolve(schemaPath) {
+      return origin(schemaPath)?.schema;
+    },
+    origin
+  };
+}
+export {
+  createSchemaDiagnosticOrigins
+};

package/dist/lib/validation/schema-loader.js

@@ -36,6 +36,7 @@ __export(schema_loader_exports, {
   getMcpProfileInputSchema: () => getMcpProfileInputSchema,
   getMcpToolSchema: () => getMcpToolSchema,
   getMcpToolSummary: () => getMcpToolSummary,
+  getMediaBuyDeliveryEnvelopeValidator: () => getMediaBuyDeliveryEnvelopeValidator,
   getRegisteredSchemaIds: () => getRegisteredSchemaIds,
   getRequestSchemaEntityPaths: () => getRequestSchemaEntityPaths,
   getSchemaDefaultByPath: () => getSchemaDefaultByPath,
@@ -44,14 +45,17 @@ __export(schema_loader_exports, {
   getSchemaValidatorByRef: () => getSchemaValidatorByRef,
   getToolSchemaDocument: () => getToolSchemaDocument,
   getValidator: () => getValidator,
+  getValidatorDiagnosticOrigin: () => getValidatorDiagnosticOrigin,
   hasSchemaBundle: () => hasSchemaBundle,
   isExternalSchemaRootActive: () => isExternalSchemaRootActive,
   isIdentity33SchemaScope: () => isIdentity33SchemaScope,
   listValidatorKeys: () => listValidatorKeys,
   registerExternalSchemaRoot: () => registerExternalSchemaRoot,
+  relaxResponseRoot: () => relaxResponseRoot,
   resolveBundleKey: () => resolveBundleKey,
   resolveSchemaRoot: () => resolveSchemaRoot,
   resolveServedValidationVersion: () => resolveServedValidationVersion,
+  resolveValidatorDiagnosticPath: () => resolveValidatorDiagnosticPath,
   schemaAllowsTopLevelField: () => schemaAllowsTopLevelField,
   toReleasePrecisionWire: () => toReleasePrecisionWire,
   unregisterExternalSchemaRoot: () => unregisterExternalSchemaRoot,
@@ -208,6 +212,13 @@ function compareBundleNamesDesc(a, b) {
   return b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" });
 }
 const states = /* @__PURE__ */ new Map();
+const validatorDiagnosticOrigins = /* @__PURE__ */ new WeakMap();
+function resolveValidatorDiagnosticPath(validator, schemaPath) {
+  return validatorDiagnosticOrigins.get(validator)?.resolve(schemaPath);
+}
+function getValidatorDiagnosticOrigin(validator, schemaPath) {
+  return validatorDiagnosticOrigins.get(validator)?.origin(schemaPath);
+}
 const schemaRefValidators = /* @__PURE__ */ new Map();
 const keywordSchemaRefValidators = /* @__PURE__ */ new WeakMap();
 let keywordCacheGeneration = 0;
@@ -472,21 +483,30 @@ function ensureInit(version) {
   const cacheKey = stateCacheKey(key, root);
   const cached = states.get(cacheKey);
   if (cached) return cached;
+  const { createSchemaDiagnosticOrigins } = require('./schema-diagnostic-origins.js');
+  const diagnosticOrigins = createSchemaDiagnosticOrigins();
+  const bundledDiagnosticOrigins = createSchemaDiagnosticOrigins();
   const ajv = new import_ajv.default({
+    inlineRefs: false,
     strict: false,
     allErrors: true,
-    allowUnionTypes: true
+    allowUnionTypes: true,
+    code: { process: diagnosticOrigins.process }
   });
   (0, import_ajv_formats.default)(ajv);
   const bundledAjv = new import_ajv.default({
+    inlineRefs: false,
     strict: false,
     allErrors: true,
-    allowUnionTypes: true
+    allowUnionTypes: true,
+    code: { process: bundledDiagnosticOrigins.process }
   });
   (0, import_ajv_formats.default)(bundledAjv);
   const state = {
     ajv,
     bundledAjv,
+    diagnosticOrigins,
+    bundledDiagnosticOrigins,
     canonicalValidators: /* @__PURE__ */ new Map(),
     fileIndex: buildFileIndex(root),
     validators: /* @__PURE__ */ new Map(),
@@ -503,7 +523,8 @@ function ensureCoreLoaded(s) {
   if (s.coreLoaded) return;
   const selectedToolsById = /* @__PURE__ */ new Map();
   const responseToolFiles = /* @__PURE__ */ new Set();
-  for (const [key, file] of s.fileIndex) {
+  for (const [key, indexedFile] of s.fileIndex) {
+    const file = authoredToolSchemaFile(s, indexedFile);
     const response = !key.endsWith("::request");
     if (response) responseToolFiles.add(file);
     const schema = loadJson(file);
@@ -538,17 +559,20 @@ function getValidator(toolName, direction, version = import_version.ADCP_VERSION
   const cacheKey = `${toolName}::${direction}`;
   const cached = s.validators.get(cacheKey);
   if (cached) return cached;
-  const file = s.fileIndex.get(cacheKey);
-  if (!file) return void 0;
+  const indexedFile = s.fileIndex.get(cacheKey);
+  if (!indexedFile) return void 0;
+  const file = runtimeToolSchemaFile(s, indexedFile, direction);
   const fromBundled = file.includes(`${import_path.default.sep}bundled${import_path.default.sep}`);
   if (!fromBundled) ensureCoreLoaded(s);
   const rawSchema = loadJson(file);
   const prepared = fromBundled ? stripNestedIds(rawSchema) : rawSchema;
-  const schema = direction === "request" ? prepared : relaxResponseRoot(prepared);
+  const envelope = direction === "request" ? prepared : relaxResponseRoot(prepared);
+  const schema = fromBundled ? compactSchemaForValidation(envelope) : envelope;
   const ajv = fromBundled ? s.bundledAjv : s.ajv;
   const existing = typeof schema.$id === "string" ? ajv.getSchema(schema.$id) : void 0;
   const compiled = existing ?? ajv.compile(schema);
   s.validators.set(cacheKey, compiled);
+  validatorDiagnosticOrigins.set(compiled, fromBundled ? s.bundledDiagnosticOrigins : s.diagnosticOrigins);
   return compiled;
 }
 function authoredToolSchemaFile(state, indexedFile) {
@@ -558,6 +582,23 @@ function authoredToolSchemaFile(state, indexedFile) {
   const authoredFile = import_path.default.join(state.root, relative);
   return (0, import_fs.existsSync)(authoredFile) ? authoredFile : indexedFile;
 }
+function runtimeToolSchemaFile(state, indexedFile, direction) {
+  const authoredFile = authoredToolSchemaFile(state, indexedFile);
+  if (direction === "request" || authoredFile === indexedFile) return authoredFile;
+  const hasCompositionReference = (node) => {
+    if (!node || typeof node !== "object" || Array.isArray(node)) return false;
+    const schema = node;
+    if (typeof schema.$ref === "string") return true;
+    return ["allOf", "oneOf", "anyOf"].some(
+      (keyword) => Array.isArray(schema[keyword]) && schema[keyword].some(hasCompositionReference)
+    );
+  };
+  return hasCompositionReference(loadJson(authoredFile)) ? indexedFile : authoredFile;
+}
+function compactSchemaForValidation(schema) {
+  const compactor = require('./compact-schema.js');
+  return compactor.compactSchemaForValidation(schema);
+}
 function getToolSchemaDocument(toolName, direction, version = import_version.ADCP_VERSION) {
   const state = ensureInit(version);
   const file = state.fileIndex.get(`${toolName}::${direction}`);
@@ -616,6 +657,33 @@ function getSchemaDocumentByRef(schemaRef, version = import_version.ADCP_VERSION
   };
 }
 function getSchemaValidatorByRef(schemaRef, version = import_version.ADCP_VERSION, keywords, options = {}) {
+  return compileSchemaReference(schemaRef, version, keywords, options);
+}
+function getMediaBuyDeliveryEnvelopeValidator(version) {
+  return compileSchemaReference(
+    "core/mcp-webhook-payload.json",
+    version,
+    void 0,
+    {},
+    {
+      key: "media-buy-delivery-envelope",
+      project: (schema) => ({
+        ...schema,
+        properties: {
+          ...schema.properties,
+          // The 3.0 task-type enum predates this documented reporting task. All
+          // releases use the same concrete discriminator on delivery envelopes.
+          task_type: { const: "media_buy_delivery" },
+          // The caller validates this independently against the served report
+          // schema, so result errors cannot masquerade as envelope errors.
+          result: {}
+        },
+        required: [.../* @__PURE__ */ new Set([...schema.required ?? [], "task_type", "result"])]
+      })
+    }
+  );
+}
+function compileSchemaReference(schemaRef, version, keywords, options, projection) {
   const bundleKey = resolveBundleKey(version);
   const root = resolveSchemaRoot(version);
   const normalized = normalizeSchemaRef(schemaRef);
@@ -630,12 +698,13 @@ function getSchemaValidatorByRef(schemaRef, version = import_version.ADCP_VERSIO
     cache = entry.validators;
   }
   const allErrors = options.allErrors ?? false;
-  const cacheKey = `${stateCacheKey(bundleKey, root)}\0schema-ref::${normalized}\0all-errors::${allErrors}`;
+  const cacheKey = `${stateCacheKey(bundleKey, root)}\0schema-ref::${normalized}\0all-errors::${allErrors}\0projection::${projection?.key ?? "raw"}`;
   const cached = cache.get(cacheKey);
   if (cached) return cached;
   const file = import_path.default.join(root, normalized);
   if (!(0, import_fs.existsSync)(file)) return void 0;
   const ajv = new import_ajv.default({
+    inlineRefs: false,
     strict: false,
     // Schema-ref validators process remote webhook payloads. By default they
     // fail on the first violation so deeply nested hostile input cannot
@@ -646,7 +715,8 @@ function getSchemaValidatorByRef(schemaRef, version = import_version.ADCP_VERSIO
   });
   (0, import_ajv_formats.default)(ajv);
   for (const keyword of keywords ?? []) ajv.addKeyword(keyword);
-  const rawSchema = identity33ReferenceSchema(loadJson(file), version);
+  const authoredSchema = identity33ReferenceSchema(loadJson(file), version);
+  const rawSchema = projection ? projection.project(authoredSchema) : authoredSchema;
   const dependencySchemas = [];
   const registeredIds = /* @__PURE__ */ new Map();
   for (const schemaFile of walkJsonFiles(root)) {
@@ -656,8 +726,8 @@ function getSchemaValidatorByRef(schemaRef, version = import_version.ADCP_VERSIO
     }
     if (schemaFile === file) continue;
     const schema = identity33ReferenceSchema(loadJson(schemaFile), version);
-    if ((keywords || allErrors) && typeof schema.$id === "string") {
-      const previous = schema.$id === rawSchema.$id ? rawSchema : registeredIds.get(schema.$id);
+    if (typeof schema.$id === "string") {
+      const previous = schema.$id === authoredSchema.$id ? authoredSchema : registeredIds.get(schema.$id);
       if (previous && !(0, import_node_util.isDeepStrictEqual)(previous, schema)) {
         throw new import_errors.ConfigurationError("Schema validation requires unambiguous schema identities", "schemaRoot");
       }
@@ -687,17 +757,13 @@ function getCanonicalToolValidatorForVersion(toolName, direction, version = impo
   const ajv = ensureCanonicalAjv(state);
   const existing = typeof rawSchema.$id === "string" ? ajv.getSchema(rawSchema.$id) : void 0;
   const fromBundled = file.includes(`${import_path.default.sep}bundled${import_path.default.sep}`);
-  const compiled = existing ?? ajv.compile(fromBundled ? stripNestedIds(rawSchema) : rawSchema);
+  const compiled = existing ?? ajv.compile(fromBundled ? compactSchemaForValidation(stripNestedIds(rawSchema)) : rawSchema);
   state.canonicalValidators.set(cacheKey, compiled);
   return compiled;
 }
 function ensureCanonicalAjv(state) {
   if (state.canonicalAjv) return state.canonicalAjv;
-  const ajv = new import_ajv.default({
-    strict: false,
-    allErrors: true,
-    allowUnionTypes: true
-  });
+  const ajv = new import_ajv.default({ inlineRefs: false, strict: false, allErrors: true, allowUnionTypes: true });
   (0, import_ajv_formats.default)(ajv);
   const schemasById = /* @__PURE__ */ new Map();
   for (const schemaFile of walkJsonFiles(state.root)) {
@@ -1133,6 +1199,7 @@ function cloneJsonValue(value) {
   getMcpProfileInputSchema,
   getMcpToolSchema,
   getMcpToolSummary,
+  getMediaBuyDeliveryEnvelopeValidator,
   getRegisteredSchemaIds,
   getRequestSchemaEntityPaths,
   getSchemaDefaultByPath,
@@ -1141,14 +1208,17 @@ function cloneJsonValue(value) {
   getSchemaValidatorByRef,
   getToolSchemaDocument,
   getValidator,
+  getValidatorDiagnosticOrigin,
   hasSchemaBundle,
   isExternalSchemaRootActive,
   isIdentity33SchemaScope,
   listValidatorKeys,
   registerExternalSchemaRoot,
+  relaxResponseRoot,
   resolveBundleKey,
   resolveSchemaRoot,
   resolveServedValidationVersion,
+  resolveValidatorDiagnosticPath,
   schemaAllowsTopLevelField,
   toReleasePrecisionWire,
   unregisterExternalSchemaRoot,