@adcp/sdk 16.5.0 → 16.6.0

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,

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

@@ -154,6 +154,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;
@@ -418,21 +425,30 @@ function ensureInit(version) {
   const cacheKey = stateCacheKey(key, root);
   const cached = states.get(cacheKey);
   if (cached) return cached;
+  const { createSchemaDiagnosticOrigins } = require2("./schema-diagnostic-origins");
+  const diagnosticOrigins = createSchemaDiagnosticOrigins();
+  const bundledDiagnosticOrigins = createSchemaDiagnosticOrigins();
   const ajv = new Ajv({
+    inlineRefs: false,
     strict: false,
     allErrors: true,
-    allowUnionTypes: true
+    allowUnionTypes: true,
+    code: { process: diagnosticOrigins.process }
   });
   addFormats(ajv);
   const bundledAjv = new Ajv({
+    inlineRefs: false,
     strict: false,
     allErrors: true,
-    allowUnionTypes: true
+    allowUnionTypes: true,
+    code: { process: bundledDiagnosticOrigins.process }
   });
   addFormats(bundledAjv);
   const state = {
     ajv,
     bundledAjv,
+    diagnosticOrigins,
+    bundledDiagnosticOrigins,
     canonicalValidators: /* @__PURE__ */ new Map(),
     fileIndex: buildFileIndex(root),
     validators: /* @__PURE__ */ new Map(),
@@ -449,7 +465,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);
@@ -484,17 +501,20 @@ function getValidator(toolName, direction, 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(`${path.sep}bundled${path.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) {
@@ -504,6 +524,23 @@ function authoredToolSchemaFile(state, indexedFile) {
   const authoredFile = path.join(state.root, relative);
   return 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 = require2("./compact-schema");
+  return compactor.compactSchemaForValidation(schema);
+}
 function getToolSchemaDocument(toolName, direction, version = ADCP_VERSION) {
   const state = ensureInit(version);
   const file = state.fileIndex.get(`${toolName}::${direction}`);
@@ -562,6 +599,33 @@ function getSchemaDocumentByRef(schemaRef, version = ADCP_VERSION) {
   };
 }
 function getSchemaValidatorByRef(schemaRef, 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);
@@ -576,12 +640,13 @@ function getSchemaValidatorByRef(schemaRef, version = ADCP_VERSION, keywords, op
     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 = path.join(root, normalized);
   if (!existsSync(file)) return void 0;
   const ajv = new Ajv({
+    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
@@ -592,7 +657,8 @@ function getSchemaValidatorByRef(schemaRef, version = ADCP_VERSION, keywords, op
   });
   addFormats(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)) {
@@ -602,8 +668,8 @@ function getSchemaValidatorByRef(schemaRef, version = ADCP_VERSION, keywords, op
     }
     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 && !isDeepStrictEqual(previous, schema)) {
         throw new ConfigurationError("Schema validation requires unambiguous schema identities", "schemaRoot");
       }
@@ -633,17 +699,13 @@ function getCanonicalToolValidatorForVersion(toolName, direction, version = ADCP
   const ajv = ensureCanonicalAjv(state);
   const existing = typeof rawSchema.$id === "string" ? ajv.getSchema(rawSchema.$id) : void 0;
   const fromBundled = file.includes(`${path.sep}bundled${path.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 Ajv({
-    strict: false,
-    allErrors: true,
-    allowUnionTypes: true
-  });
+  const ajv = new Ajv({ inlineRefs: false, strict: false, allErrors: true, allowUnionTypes: true });
   addFormats(ajv);
   const schemasById = /* @__PURE__ */ new Map();
   for (const schemaFile of walkJsonFiles(state.root)) {
@@ -1078,6 +1140,7 @@ export {
   getMcpProfileInputSchema,
   getMcpToolSchema,
   getMcpToolSummary,
+  getMediaBuyDeliveryEnvelopeValidator,
   getRegisteredSchemaIds,
   getRequestSchemaEntityPaths,
   getSchemaDefaultByPath,
@@ -1086,14 +1149,17 @@ export {
   getSchemaValidatorByRef,
   getToolSchemaDocument,
   getValidator,
+  getValidatorDiagnosticOrigin,
   hasSchemaBundle,
   isExternalSchemaRootActive,
   isIdentity33SchemaScope,
   listValidatorKeys,
   registerExternalSchemaRoot,
+  relaxResponseRoot,
   resolveBundleKey,
   resolveSchemaRoot,
   resolveServedValidationVersion,
+  resolveValidatorDiagnosticPath,
   schemaAllowsTopLevelField,
   toReleasePrecisionWire,
   unregisterExternalSchemaRoot,

package/dist/lib/validation/schema-validator.d.mts

@@ -36,27 +36,18 @@ export interface ValidationIssue {
     message: string;
     /** AJV keyword that rejected the payload (e.g., `required`, `type`). */
     keyword: string;
-    /** Path inside the schema that rejected the payload. */
+    /**
+     * AJV's original function-relative path in the compiled runtime schema.
+     * Factoring can change paths; they are diagnostic details rather than stable
+     * selectors into the public bundled document. Synthetic origin IDs stay internal.
+     */
     schemaPath: string;
     /**
-     * `$id` of the rejecting schema. Resolved by finding the longest
-     * registered AJV `$id` that prefixes {@link schemaPath}.
-     *
-     * Bundling caveat: AdCP ships most tools through `schemas/cache/<v>/bundled/`
-     * with `$ref`s pre-resolved and inner `$id`s stripped at bundle time. For
-     * those tools, `schemaId` resolves to the response root (e.g.
-     * `/schemas/3.0.4/bundled/signals/activate-signal-response.json`), not
-     * the deeper sub-schema. Tools served from the flat tree (`governance/`,
-     * `brand/`, etc.) preserve sub-schema `$id`s, so `schemaId` can land on
-     * something deeper like `/schemas/3.0.4/core/activation-key.json`. Either
-     * way, the field names exactly the schema the validator looked at.
-     *
-     * Always projected — the `$id` is the published spec URI, not internal
-     * handler shape. (Same precedent as {@link ValidationIssue.variants} and
-     * {@link ValidationIssue.allowedValues}, both of which already ship
-     * always-on with the same rationale.)
-     *
-     * Absent only when the rejecting schema didn't declare an `$id`.
+     * Effective `$id` of the rejecting resource, including embedded resources.
+     * Bundled documents may strip nested IDs, in which case the tool root is
+     * the available identity. Unsupported origin metadata conservatively falls
+     * back to the compiled root ID; anonymous resources can omit this field.
+     * Always projected because published schema IDs are protocol metadata.
      */
     schemaId?: string;
     /**