@adcp/sdk 16.5.0 → 16.6.0

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

@@ -0,0 +1,250 @@
+import { createHash } from "node:crypto";
+const COMPACT_DEFINITIONS_KEY = "x-adcp-compact-definitions";
+const SCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set(["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"]);
+const SCHEMA_ARRAY_KEYWORDS = /* @__PURE__ */ new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+const SCHEMA_VALUE_KEYWORDS = /* @__PURE__ */ new Set([
+  "additionalProperties",
+  "additionalItems",
+  "contains",
+  "if",
+  "then",
+  "else",
+  "not",
+  "propertyNames",
+  "contentSchema",
+  "unevaluatedProperties",
+  "unevaluatedItems"
+]);
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function forEachChildSchema(schema, visit) {
+  for (const [keyword, value] of Object.entries(schema)) {
+    if (SCHEMA_MAP_KEYWORDS.has(keyword) && isObject(value)) {
+      for (const child of Object.values(value)) visit(child);
+    } else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+      for (const child of value) visit(child);
+    } else if (SCHEMA_VALUE_KEYWORDS.has(keyword)) {
+      visit(value);
+    } else if (keyword === "items") {
+      if (Array.isArray(value)) {
+        for (const child of value) visit(child);
+      } else {
+        visit(value);
+      }
+    } else if (keyword === "dependencies" && isObject(value)) {
+      for (const child of Object.values(value)) {
+        if (!Array.isArray(child)) visit(child);
+      }
+    }
+  }
+}
+function cloneData(value) {
+  if (Array.isArray(value)) return value.map(cloneData);
+  if (!isObject(value)) return value;
+  return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, cloneData(child)]));
+}
+function compactBundledSchema(root, options = {}) {
+  const referenceCounts = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const countSchema = (value) => {
+    if (!isObject(value)) return;
+    referenceCounts.set(value, (referenceCounts.get(value) ?? 0) + 1);
+    if (visited.has(value)) return;
+    visited.add(value);
+    forEachChildSchema(value, countSchema);
+  };
+  countSchema(root);
+  const pointerAddressedNodes = /* @__PURE__ */ new Set();
+  const unionAlternatives = /* @__PURE__ */ new Set();
+  if (options.maxInlineSchemaBytes !== void 0) {
+    const rootUrl = new URL(typeof root.$id === "string" ? root.$id : "", "https://adcp.invalid/");
+    rootUrl.hash = "";
+    for (const schema of visited) {
+      for (const keyword of ["oneOf", "anyOf"]) {
+        const alternatives = schema[keyword];
+        if (Array.isArray(alternatives)) {
+          for (const alternative of alternatives) if (isObject(alternative)) unionAlternatives.add(alternative);
+        }
+      }
+      if (typeof schema.$ref !== "string") continue;
+      let fragment;
+      try {
+        const target = new URL(schema.$ref, rootUrl);
+        fragment = decodeURIComponent(target.hash.slice(1));
+        target.hash = "";
+        if (target.href !== rootUrl.href || !fragment.startsWith("/")) continue;
+      } catch {
+        continue;
+      }
+      let value = root;
+      for (const segment of fragment.slice(1).split("/")) {
+        if (isObject(value)) pointerAddressedNodes.add(value);
+        if (!isObject(value) && !Array.isArray(value)) break;
+        const key = segment.replace(/~1/g, "/").replace(/~0/g, "~");
+        value = value[key];
+      }
+      if (isObject(value)) pointerAddressedNodes.add(value);
+    }
+  }
+  const signatureCache = /* @__PURE__ */ new Map();
+  const weightCache = /* @__PURE__ */ new Map();
+  const schemaSignature = (schema) => {
+    const cached = signatureCache.get(schema);
+    if (cached) return cached;
+    const hash = createHash("sha256");
+    const updateHash = (value) => {
+      hash.update(`${Buffer.byteLength(value)}:`);
+      hash.update(value);
+    };
+    let weight = 2;
+    for (const [keyword, value] of Object.entries(schema)) {
+      updateHash(keyword);
+      if (SCHEMA_MAP_KEYWORDS.has(keyword) && isObject(value)) {
+        for (const [key, child] of Object.entries(value)) {
+          updateHash(key);
+          if (isObject(child)) {
+            updateHash(schemaSignature(child));
+            weight += weightCache.get(child) ?? 0;
+          } else {
+            const serialized = JSON.stringify(child);
+            updateHash(serialized);
+            weight += Buffer.byteLength(serialized);
+          }
+        }
+      } else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+        for (const child of value) {
+          if (isObject(child)) {
+            updateHash(schemaSignature(child));
+            weight += weightCache.get(child) ?? 0;
+          } else {
+            const serialized = JSON.stringify(child);
+            updateHash(serialized);
+            weight += Buffer.byteLength(serialized);
+          }
+        }
+      } else if (SCHEMA_VALUE_KEYWORDS.has(keyword) && isObject(value)) {
+        updateHash(schemaSignature(value));
+        weight += weightCache.get(value) ?? 0;
+      } else if (keyword === "items") {
+        updateHash(Array.isArray(value) ? "tuple" : "single");
+        const children = Array.isArray(value) ? value : [value];
+        for (const child of children) {
+          if (isObject(child)) {
+            updateHash(schemaSignature(child));
+            weight += weightCache.get(child) ?? 0;
+          } else {
+            const serialized = JSON.stringify(child);
+            updateHash(serialized);
+            weight += Buffer.byteLength(serialized);
+          }
+        }
+      } else if (keyword === "dependencies" && isObject(value)) {
+        for (const [key, child] of Object.entries(value)) {
+          updateHash(key);
+          if (isObject(child)) {
+            updateHash(schemaSignature(child));
+            weight += weightCache.get(child) ?? 0;
+          } else {
+            const serialized = JSON.stringify(child);
+            updateHash(serialized);
+            weight += Buffer.byteLength(serialized);
+          }
+        }
+      } else {
+        const serialized = JSON.stringify(value);
+        updateHash(serialized);
+        weight += Buffer.byteLength(serialized);
+      }
+    }
+    const signature = hash.digest("hex");
+    signatureCache.set(schema, signature);
+    weightCache.set(schema, weight);
+    return signature;
+  };
+  const signatureGroups = /* @__PURE__ */ new Map();
+  for (const schema of visited) {
+    if (schema === root || pointerAddressedNodes.has(schema) || unionAlternatives.has(schema)) continue;
+    const signature = schemaSignature(schema);
+    const group = signatureGroups.get(signature) ?? [];
+    group.push(schema);
+    signatureGroups.set(signature, group);
+  }
+  const sharedNames = /* @__PURE__ */ new Map();
+  const sharedDefinitions = /* @__PURE__ */ new Map();
+  const reservedNames = new Set(isObject(root.$defs) ? Object.keys(root.$defs) : []);
+  let sharedIndex = 0;
+  for (const group of signatureGroups.values()) {
+    const useCount = group.reduce((sum, schema) => sum + (referenceCounts.get(schema) ?? 0), 0);
+    const weight = weightCache.get(group[0]) ?? 0;
+    const identityShared = group.some((schema) => (referenceCounts.get(schema) ?? 0) > 1);
+    const largeValidationNode = options.maxInlineSchemaBytes !== void 0 && weight >= options.maxInlineSchemaBytes;
+    if (!largeValidationNode && (useCount < 2 || !identityShared && weight < 256)) continue;
+    let name;
+    do
+      name = `__adcp_shared_${sharedIndex++}`;
+    while (reservedNames.has(name));
+    reservedNames.add(name);
+    for (const schema of group) sharedNames.set(schema, name);
+    sharedDefinitions.set(name, group[0]);
+  }
+  const encodeSchema = (schema, expanding, ancestors = /* @__PURE__ */ new Set()) => {
+    if (!isObject(schema)) return schema;
+    const sharedName = sharedNames.get(schema);
+    if (sharedName && schema !== expanding) return { $ref: `#/$defs/${sharedName}` };
+    if (ancestors.has(schema)) {
+      if (!sharedName) throw new Error("Dereferenced schema contains an unaddressable cycle");
+      return { $ref: `#/$defs/${sharedName}` };
+    }
+    const nextAncestors = new Set(ancestors);
+    nextAncestors.add(schema);
+    const encoded = {};
+    for (const [keyword, value] of Object.entries(schema)) {
+      if (SCHEMA_MAP_KEYWORDS.has(keyword) && isObject(value)) {
+        encoded[keyword] = Object.fromEntries(
+          Object.entries(value).map(([key, child]) => [key, encodeSchema(child, void 0, nextAncestors)])
+        );
+      } else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(value)) {
+        encoded[keyword] = value.map((child) => encodeSchema(child, void 0, nextAncestors));
+      } else if (SCHEMA_VALUE_KEYWORDS.has(keyword)) {
+        encoded[keyword] = encodeSchema(value, void 0, nextAncestors);
+      } else if (keyword === "items") {
+        encoded[keyword] = Array.isArray(value) ? value.map((child) => encodeSchema(child, void 0, nextAncestors)) : encodeSchema(value, void 0, nextAncestors);
+      } else if (keyword === "dependencies" && isObject(value)) {
+        encoded[keyword] = Object.fromEntries(
+          Object.entries(value).map(([key, child]) => [
+            key,
+            Array.isArray(child) ? cloneData(child) : encodeSchema(child, void 0, nextAncestors)
+          ])
+        );
+      } else {
+        encoded[keyword] = cloneData(value);
+      }
+    }
+    return encoded;
+  };
+  const compacted = encodeSchema(root, root);
+  if (compacted[COMPACT_DEFINITIONS_KEY] !== void 0) {
+    throw new Error(`Schema already contains reserved property ${COMPACT_DEFINITIONS_KEY}`);
+  }
+  const defs = isObject(compacted.$defs) ? { ...compacted.$defs } : {};
+  for (const [name, schema] of sharedDefinitions) defs[name] = encodeSchema(schema, schema);
+  if (Object.keys(defs).length > 0) compacted.$defs = defs;
+  if (sharedDefinitions.size > 0) compacted[COMPACT_DEFINITIONS_KEY] = [...sharedDefinitions.keys()];
+  return compacted;
+}
+function compactSchemaForValidation(schema) {
+  const copied = cloneData(schema);
+  const stripIds = (node, root = false) => {
+    if (!isObject(node)) return;
+    if (!root) delete node.$id;
+    forEachChildSchema(node, (child) => stripIds(child));
+  };
+  stripIds(copied, true);
+  return compactBundledSchema(copied, { maxInlineSchemaBytes: 1024 });
+}
+export {
+  COMPACT_DEFINITIONS_KEY,
+  compactBundledSchema,
+  compactSchemaForValidation
+};

package/dist/lib/validation/media-buy-delivery-report.d.mts

@@ -0,0 +1,8 @@
+import type { z } from 'zod';
+import type { MediaBuyDeliveryReport } from '../types/media-buy-delivery-report.mjs';
+/**
+ * Payload-only reporting shape at the SDK pin. Poll responses still require
+ * their task status; webhook receivers validate the separate outer envelope.
+ * Use parseMediaBuyDeliveryWebhook for strict validation at an older release.
+ */
+export declare const MediaBuyDeliveryReportSchema: z.ZodType<MediaBuyDeliveryReport>;

package/dist/lib/validation/media-buy-delivery-report.d.ts

@@ -0,0 +1,8 @@
+import type { z } from 'zod';
+import type { MediaBuyDeliveryReport } from '../types/media-buy-delivery-report';
+/**
+ * Payload-only reporting shape at the SDK pin. Poll responses still require
+ * their task status; webhook receivers validate the separate outer envelope.
+ * Use parseMediaBuyDeliveryWebhook for strict validation at an older release.
+ */
+export declare const MediaBuyDeliveryReportSchema: z.ZodType<MediaBuyDeliveryReport>;

package/dist/lib/validation/media-buy-delivery-report.js

@@ -0,0 +1,31 @@
+"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 media_buy_delivery_report_exports = {};
+__export(media_buy_delivery_report_exports, {
+  MediaBuyDeliveryReportSchema: () => MediaBuyDeliveryReportSchema
+});
+module.exports = __toCommonJS(media_buy_delivery_report_exports);
+var import_schemas = require('../types/schemas.generated.js');
+const MediaBuyDeliveryReportSchema = /* @__PURE__ */ import_schemas.GetMediaBuyDeliveryResponseSchema.omit({
+  status: true
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MediaBuyDeliveryReportSchema
+});

package/dist/lib/validation/media-buy-delivery-report.mjs

@@ -0,0 +1,7 @@
+import { GetMediaBuyDeliveryResponseSchema } from "../types/schemas.generated.mjs";
+const MediaBuyDeliveryReportSchema = /* @__PURE__ */ GetMediaBuyDeliveryResponseSchema.omit({
+  status: true
+});
+export {
+  MediaBuyDeliveryReportSchema
+};

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
+});