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

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;
     /**

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

@@ -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;
     /**

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

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var schema_validator_exports = {};
 __export(schema_validator_exports, {
+  compactUnionErrors: () => compactUnionErrors,
   formatDiscriminator: () => formatDiscriminator,
   formatIssueLine: () => formatIssueLine,
   formatIssues: () => formatIssues,
@@ -46,17 +47,18 @@ function extractSchemaId(schemaPath, rootSchema, registeredIds) {
 }
 function formatIssue(err, ctx) {
   const instancePath = err.instancePath || "";
-  const missingProperty = err.keyword === "required" && err.params && typeof err.params.missingProperty === "string" ? `/${err.params.missingProperty}` : "";
+  const missingProperty = err.keyword === "required" && err.params && typeof err.params.missingProperty === "string" ? `/${err.params.missingProperty.replace(/~/g, "~0").replace(/\//g, "~1")}` : "";
   const isEnum = err.keyword === "enum" && err.params != null && Array.isArray(err.params.allowedValues);
   const allowedValues = isEnum ? err.params.allowedValues : void 0;
   const message = isEnum ? `must be one of: ${allowedValues.map((v) => JSON.stringify(v)).join(", ")}` : err.message ?? "validation failed";
-  const schemaId = extractSchemaId(err.schemaPath, ctx.rootSchema, ctx.registeredIds);
+  const origin = ctx.diagnosticOrigin?.(err.__adcp_originSchemaPath ?? err.schemaPath);
+  const schemaId = origin ? origin.schemaId : extractSchemaId(err.schemaPath, ctx.rootSchema, ctx.registeredIds) ?? ctx.rootSchemaId;
   const discriminator = err.__adcp_discriminator;
   const issue = {
     pointer: `${instancePath}${missingProperty}` || "/",
     message,
     keyword: err.keyword,
-    schemaPath: err.schemaPath,
+    schemaPath: err.schemaPath === "" ? "" : origin?.schemaPath ?? err.schemaPath,
     ...schemaId !== void 0 && { schemaId },
     ...discriminator !== void 0 && discriminator.length > 0 && { discriminator },
     ...allowedValues !== void 0 && { allowedValues }
@@ -65,24 +67,19 @@ function formatIssue(err, ctx) {
   if (hint !== void 0) issue.hint = hint;
   return issue;
 }
-const FORBIDDEN_SCHEMA_PATH_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function resolveSchemaPath(rootSchema, schemaPath) {
-  if (rootSchema == null) return void 0;
-  const clean = schemaPath.replace(/^#\/?/, "");
-  if (clean.length === 0) return rootSchema;
-  let cursor = rootSchema;
-  for (const raw of clean.split("/")) {
-    if (cursor == null || typeof cursor !== "object" && !Array.isArray(cursor)) return void 0;
-    const decoded = raw.replace(/~1/g, "/").replace(/~0/g, "~");
-    if (FORBIDDEN_SCHEMA_PATH_SEGMENTS.has(decoded)) return void 0;
-    if (!Object.prototype.hasOwnProperty.call(cursor, decoded)) return void 0;
-    cursor = cursor[decoded];
-  }
-  return cursor;
+function createDiagnosticOriginResolver(validator) {
+  const memo = /* @__PURE__ */ new Map();
+  return (schemaPath) => {
+    if (memo.has(schemaPath)) return memo.get(schemaPath);
+    if (memo.size >= 1024) return void 0;
+    const resolved = (0, import_schema_loader.getValidatorDiagnosticOrigin)(validator, schemaPath);
+    memo.set(schemaPath, resolved);
+    return resolved;
+  };
 }
-function* expandNotErrors(errors, rootSchema, payload) {
+function* expandNotErrors(errors, resolveDiagnosticPath, payload) {
   for (const error of errors) {
-    const rule = error.keyword === "not" ? resolveSchemaPath(rootSchema, error.schemaPath) : void 0;
+    const rule = error.keyword === "not" ? resolveDiagnosticPath(error.instancePath, error.schemaPath) : void 0;
     const branches = rule && typeof rule === "object" ? rule.anyOf : void 0;
     if (!Array.isArray(branches) || branches.length === 0 || Object.keys(rule).length !== 1) {
       yield error;
@@ -126,47 +123,118 @@ function* expandNotErrors(errors, rootSchema, payload) {
   }
 }
 function formatValidationIssues(errors, ctx, payload) {
+  const resolveDiagnosticPath = (_instancePath, path) => ctx.diagnosticOrigin?.(path)?.schema;
   function* formatted() {
-    for (const error of expandNotErrors(compactUnionErrors(errors, ctx.rootSchema), ctx.rootSchema, payload)) {
-      yield enrichWithVariants(formatIssue(error, ctx), ctx.rootSchema);
+    for (const error of expandNotErrors(
+      compactUnionErrors(errors, resolveDiagnosticPath),
+      resolveDiagnosticPath,
+      payload
+    )) {
+      yield enrichWithVariants(
+        formatIssue(error, ctx),
+        (_instance, _publicPath) => resolveDiagnosticPath(error.instancePath, error.schemaPath)
+      );
     }
   }
   return ctx.toolName === "sync_accounts" ? [...formatted()] : (0, import_diagnostic_limits.boundValidationIssues)(formatted());
 }
-function compactUnionErrors(errors, rootSchema) {
-  if (errors.length === 0) return [...errors];
-  const errorsByOneOfPath = /* @__PURE__ */ new Map();
-  for (const e of errors) {
-    const m = e.schemaPath.match(/^(.*\/(?:oneOf|anyOf))\/\d+(?:\/|$)/);
-    if (!m) continue;
-    const root = m[1];
-    const bucket = errorsByOneOfPath.get(root);
-    if (bucket) bucket.push(e);
-    else errorsByOneOfPath.set(root, [e]);
+function inlineUnionOwner(error, unionPath, variants) {
+  const instance = error.instancePath ? error.instancePath.slice(1).split("/") : [];
+  let pointer;
+  try {
+    pointer = error.schemaPath.slice(unionPath.length + 1).split("/").map((segment) => decodeURIComponent(segment).replace(/~1/g, "/").replace(/~0/g, "~"));
+  } catch {
+    return void 0;
+  }
+  let cursor = variants;
+  const consumed = [];
+  for (let index = 0; index < pointer.length - 1; index++) {
+    if (!cursor || typeof cursor !== "object") return void 0;
+    const keyword = pointer[index];
+    if (!Array.isArray(cursor) && ["properties", "patternProperties"].includes(keyword)) {
+      const property = pointer[++index];
+      if (property === void 0) return void 0;
+      consumed.push(keyword === "properties" ? property : void 0);
+      cursor = cursor[keyword]?.[property];
+    } else if (!Array.isArray(cursor) && [
+      "items",
+      "prefixItems",
+      "additionalItems",
+      "contains",
+      "additionalProperties",
+      "unevaluatedProperties",
+      "unevaluatedItems"
+    ].includes(keyword)) {
+      consumed.push(void 0);
+      cursor = cursor[keyword];
+      if (Array.isArray(cursor)) cursor = cursor[Number(pointer[++index])];
+    } else cursor = cursor[keyword];
   }
+  if (consumed.length > instance.length) return void 0;
+  for (let index = 0; index < consumed.length; index++) {
+    const expected = consumed[index];
+    const actual = instance[instance.length - consumed.length + index].replace(/~1/g, "/").replace(/~0/g, "~");
+    if (expected !== void 0 && actual !== expected) return void 0;
+  }
+  return consumed.length ? instance.length === consumed.length ? "" : "/" + instance.slice(0, -consumed.length).join("/") : error.instancePath;
+}
+function compactUnionErrors(errors, resolveDiagnosticPath) {
+  if (errors.length === 0) return [...errors];
   const dropped = /* @__PURE__ */ new Set();
   const added = [];
-  const unionRoots = errors.filter((e) => e.keyword === "oneOf" || e.keyword === "anyOf").slice().sort((a, b) => b.schemaPath.length - a.schemaPath.length);
+  const unionRoots = errors.filter((e) => e.keyword === "oneOf" || e.keyword === "anyOf").slice().sort((a, b) => b.instancePath.length - a.instancePath.length || b.schemaPath.length - a.schemaPath.length);
+  const unionOwners = /* @__PURE__ */ new Map();
+  for (const root of unionRoots) {
+    const owners = unionOwners.get(root.schemaPath) ?? /* @__PURE__ */ new Set();
+    owners.add(root.instancePath);
+    unionOwners.set(root.schemaPath, owners);
+  }
+  const errorsByOwner = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    const match = error.schemaPath.match(/^(.*\/(?:oneOf|anyOf))\/\d+(?:\/|$)/);
+    if (!match) continue;
+    const schemaPath = match[1];
+    const owners = unionOwners.get(schemaPath);
+    if (!owners) continue;
+    const variants = resolveDiagnosticPath(error.instancePath, schemaPath);
+    const nearest = inlineUnionOwner(error, schemaPath, variants);
+    if (nearest === void 0 || !owners.has(nearest)) continue;
+    const locations = errorsByOwner.get(schemaPath) ?? /* @__PURE__ */ new Map();
+    const bucket = locations.get(nearest) ?? [];
+    bucket.push(error);
+    locations.set(nearest, bucket);
+    errorsByOwner.set(schemaPath, locations);
+  }
+  const processedRoots = /* @__PURE__ */ new Map();
   for (const root of unionRoots) {
     if (dropped.has(root)) continue;
     const oneOfPath = root.schemaPath;
     const rootInstance = root.instancePath;
-    const candidateErrors = errorsByOneOfPath.get(oneOfPath) ?? [];
+    if (root.keyword === "oneOf" && Array.isArray(root.params.passingSchemas) && root.params.passingSchemas.length > 1)
+      continue;
+    const variantSchemas = resolveDiagnosticPath(rootInstance, oneOfPath);
+    if (!Array.isArray(variantSchemas)) continue;
+    const processed = processedRoots.get(oneOfPath) ?? /* @__PURE__ */ new Set();
+    if (processed.has(rootInstance)) {
+      dropped.add(root);
+      continue;
+    }
+    processed.add(rootInstance);
+    processedRoots.set(oneOfPath, processed);
+    const candidateErrors = errorsByOwner.get(oneOfPath)?.get(rootInstance) ?? [];
     const byVariant = /* @__PURE__ */ new Map();
     for (const e of candidateErrors) {
       if (e === root || dropped.has(e)) continue;
       const tail = e.schemaPath.slice(oneOfPath.length + 1);
       const m = tail.match(/^(\d+)(?:\/|$)/);
       if (!m) continue;
-      if (e.instancePath !== rootInstance && !e.instancePath.startsWith(rootInstance + "/")) continue;
       const idx = parseInt(m[1], 10);
       const bucket = byVariant.get(idx);
       if (bucket) bucket.push(e);
       else byVariant.set(idx, [e]);
     }
     if (byVariant.size === 0) continue;
-    const variantSchemas = resolveSchemaPath(rootSchema, oneOfPath);
-    const variantArr = Array.isArray(variantSchemas) ? variantSchemas : [];
+    const variantArr = variantSchemas;
     const constAsserters = /* @__PURE__ */ new Map();
     for (let i = 0; i < variantArr.length; i++) {
       const variant = variantArr[i];
@@ -213,6 +281,7 @@ function compactUnionErrors(errors, rootSchema) {
         ...sample,
         keyword: "enum",
         schemaPath: "",
+        __adcp_originSchemaPath: sample.schemaPath,
         message: `must be one of: ${allowedValues.map((v) => JSON.stringify(v)).join(", ")}`,
         params: { allowedValues }
       });
@@ -243,12 +312,23 @@ function compactUnionErrors(errors, rootSchema) {
         }
       }
     }
-    const allVariantsHaveNot = variantsWithNotFailure.size === byVariant.size && byVariant.size > 0;
+    const allVariantsHaveNot = variantsWithNotFailure.size === variantSchemas.length && variantSchemas.length > 0;
+    const contradictedVariants = /* @__PURE__ */ new Set();
+    for (const [relativePath, asserters] of constAsserters) {
+      const emitted = /* @__PURE__ */ new Set();
+      for (const [index, residual] of residualByVariant) {
+        if (residual.some((error) => error.keyword === "const" && error.instancePath === rootInstance + relativePath))
+          emitted.add(index);
+      }
+      if ([...asserters.keys()].some((index) => !emitted.has(index))) {
+        for (const index of emitted) if (asserters.has(index)) contradictedVariants.add(index);
+      }
+    }
     let bestIdx = -1;
     let bestCount = Infinity;
     let bestConsts = Infinity;
     for (const [idx, residual] of residualByVariant) {
-      if (!allVariantsHaveNot && variantsWithNotFailure.has(idx)) continue;
+      if (!allVariantsHaveNot && variantsWithNotFailure.has(idx) || contradictedVariants.has(idx)) continue;
       const constCount = residual.reduce((n, e) => e.keyword === "const" ? n + 1 : n, 0);
       if (residual.length < bestCount || residual.length === bestCount && constCount < bestConsts) {
         bestIdx = idx;
@@ -278,9 +358,9 @@ function compactUnionErrors(errors, rootSchema) {
   }
   return [...errors.filter((e) => !dropped.has(e)), ...added];
 }
-function enrichWithVariants(issue, rootSchema) {
+function enrichWithVariants(issue, resolveDiagnosticPath) {
   if (issue.keyword !== "oneOf" && issue.keyword !== "anyOf") return issue;
-  const resolved = resolveSchemaPath(rootSchema, issue.schemaPath);
+  const resolved = resolveDiagnosticPath(issue.pointer === "/" ? "" : issue.pointer, issue.schemaPath);
   if (!Array.isArray(resolved)) return issue;
   const variants = resolved.map((variant, index) => {
     if (variant == null || typeof variant !== "object") {
@@ -301,7 +381,13 @@ function validateRequest(toolName, payload, version) {
   const rootSchemaId = rootSchema && typeof rootSchema === "object" && typeof rootSchema.$id === "string" ? rootSchema.$id : void 0;
   if (valid) return { valid: true, issues: [], variant: "request", ...rootSchemaId && { schemaId: rootSchemaId } };
   const registeredIds = (0, import_schema_loader.getRegisteredSchemaIds)(version);
-  const ctx = { rootSchema, registeredIds, toolName };
+  const ctx = {
+    rootSchema,
+    rootSchemaId,
+    registeredIds,
+    toolName,
+    diagnosticOrigin: createDiagnosticOriginResolver(validator)
+  };
   return {
     valid: false,
     issues: formatValidationIssues(validator.errors ?? [], ctx, payload),
@@ -341,7 +427,13 @@ function validateResponse(toolName, payload, version) {
     };
   }
   const registeredIds = (0, import_schema_loader.getRegisteredSchemaIds)(version);
-  const ctx = { rootSchema, registeredIds, toolName };
+  const ctx = {
+    rootSchema,
+    rootSchemaId,
+    registeredIds,
+    toolName,
+    diagnosticOrigin: createDiagnosticOriginResolver(effective)
+  };
   return {
     valid: false,
     issues: formatValidationIssues(effective.errors ?? [], ctx, normalizedPayload),
@@ -375,6 +467,7 @@ function formatIssues(issues, limit = 3, options = {}) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  compactUnionErrors,
   formatDiscriminator,
   formatIssueLine,
   formatIssues,