@adcp/sdk 14.0.0-beta.8 → 14.0.0-beta.9

package/dist/lib/server/decisioning/runtime/from-platform.mjs

@@ -73,7 +73,12 @@ import {
   projectMediaBuyCreativesForDelivery,
   stripLegacyCreativeIdentity
 } from "../../../v2/projection/creative-delivery.mjs";
-import { projectV1ProductToV2 } from "../../../v2/projection/v1-to-v2.mjs";
+import {
+  projectV1ProductToV2
+} from "../../../v2/projection/v1-to-v2.mjs";
+import {
+  legacyFormatConverterFromCatalogSnapshots
+} from "../../../v2/projection/catalog-snapshot.mjs";
 import { toCanonicalOnlyResponse } from "../../../v2/projection/augment-response.mjs";
 import {
   CanonicalFormatLegacyResolutionError,
@@ -526,7 +531,7 @@ function asCanonicalListCreativesRequest(request, legacyFormatConverter, respons
   ];
   return { ...withLegacyFilter, fields };
 }
-function asCanonicalProductResponse(response, legacyFormatConverter) {
+function assertSafeGetProductsResponse(response) {
   try {
     assertSafeSemanticPayload(response, "get_products");
   } catch (error) {
@@ -537,6 +542,9 @@ function asCanonicalProductResponse(response, legacyFormatConverter) {
       suggestion: "Return an acyclic data-only product response without enumerable accessors."
     });
   }
+}
+function asCanonicalProductResponse(response, legacyFormatConverter) {
+  assertSafeGetProductsResponse(response);
   validateDualProductFormatDeclarations(response, legacyFormatConverter);
   const projected = toCanonicalOnlyResponse(response, {
     legacyFormatConverter
@@ -562,7 +570,323 @@ function asCanonicalProductResponse(response, legacyFormatConverter) {
   preserveAuthoredFormatIds(response, canonicalResponse);
   return canonicalResponse;
 }
+function legacyFormatResolutionKey(context) {
+  const formatId = context.formatId;
+  return JSON.stringify([
+    context.productId,
+    context.field,
+    formatId.agent_url,
+    formatId.id,
+    formatId.width ?? null,
+    formatId.height ?? null,
+    formatId.duration_ms ?? null
+  ]);
+}
+function preparePerProductProjectionCatalogs(response, fallback) {
+  assertSafeGetProductsResponse(response);
+  if (!Array.isArray(response.products)) return { response, converter: fallback };
+  assertNoReservedLegacyRouteMetadata(response.products, "products");
+  const converters = /* @__PURE__ */ new Map();
+  const productIdCounts = /* @__PURE__ */ new Map();
+  for (const product of response.products) {
+    if (!product || typeof product !== "object" || Array.isArray(product)) continue;
+    const productId = product.product_id;
+    if (typeof productId === "string") productIdCounts.set(productId, (productIdCounts.get(productId) ?? 0) + 1);
+  }
+  let strippedCatalogMetadata = false;
+  const products = response.products.map((product) => {
+    if (!product || typeof product !== "object" || Array.isArray(product)) return product;
+    const record = product;
+    if (!Object.prototype.hasOwnProperty.call(record, "projectionCatalogs")) return product;
+    strippedCatalogMetadata = true;
+    const { projectionCatalogs, ...wireProduct } = record;
+    if (!Array.isArray(projectionCatalogs)) {
+      throw new AdcpError("INVALID_REQUEST", {
+        message: "get_products projectionCatalogs must be an array of immutable catalog snapshots.",
+        field: `products[${String(record.product_id ?? "?")}].projectionCatalogs`
+      });
+    }
+    if (typeof record.product_id === "string" && (productIdCounts.get(record.product_id) ?? 0) > 1) {
+      throw new AdcpError("INVALID_REQUEST", {
+        message: "get_products projection catalogs require unique product identifiers.",
+        field: `products[${record.product_id}].projectionCatalogs`
+      });
+    }
+    if (projectionCatalogs.length > 0 && typeof record.product_id === "string") {
+      if (converters.has(record.product_id)) {
+        throw new AdcpError("INVALID_REQUEST", {
+          message: "get_products cannot attach different projection catalogs to duplicate product identifiers.",
+          field: `products[${record.product_id}].projectionCatalogs`
+        });
+      }
+      const converter2 = legacyFormatConverterFromCatalogSnapshots(
+        projectionCatalogs
+      );
+      if (converter2) {
+        converters.set(record.product_id, converter2);
+        const placements = wireProduct.placements;
+        if (Array.isArray(placements)) {
+          for (let placementIndex = 0; placementIndex < placements.length; placementIndex++) {
+            const placement = placements[placementIndex];
+            if (!placement || typeof placement !== "object" || Array.isArray(placement)) continue;
+            const placementRecord = placement;
+            const placementId = typeof placementRecord.placement_id === "string" ? placementRecord.placement_id : String(placementIndex);
+            const projectionProductId = `${record.product_id}:placement:${placementId}`;
+            if (converters.has(projectionProductId)) {
+              throw new AdcpError("INVALID_REQUEST", {
+                message: "get_products projection catalog scopes resolve to a duplicate product identifier.",
+                field: `products[${record.product_id}].placements[${placementIndex}]`
+              });
+            }
+            converters.set(projectionProductId, converter2);
+          }
+        }
+      }
+    }
+    return wireProduct;
+  });
+  const converter = converters.size === 0 ? fallback : (context) => {
+    const productConverter = converters.get(context.productId);
+    const resolved = productConverter?.(context);
+    return resolved === void 0 ? fallback?.(context) : resolved;
+  };
+  return {
+    response: strippedCatalogMetadata ? { ...response, products } : response,
+    converter
+  };
+}
+const DEFAULT_LEGACY_FORMAT_RESOLVER_TIMEOUT_MS = 1e4;
+const DEFAULT_LEGACY_FORMAT_RESOLVER_CONCURRENCY = 8;
+const MAX_LEGACY_FORMAT_RESOLVER_TIMEOUT_MS = 2147483647;
+const MAX_LEGACY_FORMAT_RESOLVER_CONCURRENCY = 64;
+function legacyFormatResolverLimit(value, fallback, field, maximum) {
+  if (value === void 0) return fallback;
+  if (!Number.isSafeInteger(value) || value <= 0 || maximum !== void 0 && value > maximum) {
+    const range = maximum === void 0 ? "a positive safe integer" : `an integer between 1 and ${maximum}`;
+    throw new PlatformConfigError(`${field} must be ${range}.`);
+  }
+  return value;
+}
+function legacyFormatResolverAbortError(signal) {
+  return signal.reason instanceof Error ? signal.reason : new Error("legacyCreativeFormatResolver was aborted before projection completed.");
+}
+function createLegacyFormatResolverSignal(requestSignal, timeoutMs) {
+  const controller = new AbortController();
+  const abortFromRequest = () => controller.abort(requestSignal?.reason);
+  if (requestSignal?.aborted) abortFromRequest();
+  else requestSignal?.addEventListener("abort", abortFromRequest, { once: true });
+  const timeout = controller.signal.aborted ? void 0 : setTimeout(
+    () => controller.abort(new Error(`legacyCreativeFormatResolver exceeded its ${timeoutMs}ms deadline.`)),
+    timeoutMs
+  );
+  return {
+    signal: controller.signal,
+    dispose() {
+      if (timeout !== void 0) clearTimeout(timeout);
+      requestSignal?.removeEventListener("abort", abortFromRequest);
+    }
+  };
+}
+async function invokeLegacyFormatResolver(resolver, context, signal) {
+  if (signal.aborted) throw legacyFormatResolverAbortError(signal);
+  let abortListener;
+  const aborted = new Promise((_resolve, reject) => {
+    abortListener = () => reject(legacyFormatResolverAbortError(signal));
+    signal.addEventListener("abort", abortListener, { once: true });
+  });
+  try {
+    return await Promise.race([Promise.resolve().then(() => resolver({ ...context, signal })), aborted]);
+  } finally {
+    if (abortListener) signal.removeEventListener("abort", abortListener);
+  }
+}
+async function resolveLegacyProductFormats(response, converter, resolver, requestContext) {
+  if (!resolver) return converter;
+  assertSafeGetProductsResponse(response);
+  if (!Array.isArray(response.products)) return converter;
+  const resolutions = /* @__PURE__ */ new Map();
+  const pending = [];
+  const scanScope = (projectionProduct, resolverProductId, resolverFieldPrefix) => {
+    if (Array.isArray(projectionProduct.format_options)) return;
+    for (let index = 0; index < projectionProduct.format_ids.length; index++) {
+      const formatId = projectionProduct.format_ids[index];
+      if (!formatId || typeof formatId !== "object" || Array.isArray(formatId)) continue;
+      const projectionField = `products[${projectionProduct.product_id}].format_ids[${index}]`;
+      const resolverField = `${resolverFieldPrefix}.format_ids[${index}]`;
+      const projectionContext = {
+        formatId,
+        productId: projectionProduct.product_id,
+        field: projectionField
+      };
+      const contextAwareConverter = converter ? (context) => converter({ ...context, field: projectionField }) : void 0;
+      const alreadyProjected = projectV1ProductToV2(
+        { ...projectionProduct, format_ids: [formatId] },
+        { legacyFormatConverter: contextAwareConverter }
+      );
+      if (alreadyProjected.diagnostics.length === 0) continue;
+      let resolverEligible = false;
+      projectV1ProductToV2(
+        { ...projectionProduct, format_ids: [formatId] },
+        {
+          legacyFormatConverter: () => {
+            resolverEligible = true;
+            return {
+              format_option_id: "__legacy_resolver_probe__",
+              format_kind: "custom",
+              format_shape: "__legacy_resolver_probe__",
+              format_schema: {
+                uri: "https://adcontextprotocol.org/schemas/legacy-resolver-probe.json",
+                digest: `sha256:${"0".repeat(64)}`
+              },
+              params: {}
+            };
+          }
+        }
+      );
+      if (!resolverEligible) continue;
+      const key = legacyFormatResolutionKey(projectionContext);
+      const frozenFormatId = Object.freeze({ ...formatId });
+      pending.push(async (signal) => {
+        try {
+          const value = await invokeLegacyFormatResolver(
+            resolver,
+            {
+              formatId: frozenFormatId,
+              productId: resolverProductId,
+              field: resolverField,
+              operation: "get_products",
+              ...requestContext.servedAdcpVersion !== void 0 && {
+                servedAdcpVersion: requestContext.servedAdcpVersion
+              },
+              ...requestContext.accountId !== void 0 && { accountId: requestContext.accountId }
+            },
+            signal
+          );
+          resolutions.set(key, value);
+        } catch (error) {
+          resolutions.set(key, { resolutionError: error });
+        }
+      });
+    }
+  };
+  for (const product of response.products) {
+    if (!isProjectionProductInput(product)) continue;
+    if (Array.isArray(product.format_ids)) {
+      scanScope(product, product.product_id, `products[${product.product_id}]`);
+    }
+    const placements = product.placements;
+    if (!Array.isArray(placements)) continue;
+    for (let placementIndex = 0; placementIndex < placements.length; placementIndex++) {
+      const placement = placements[placementIndex];
+      if (!placement || typeof placement !== "object" || Array.isArray(placement)) continue;
+      const placementRecord = placement;
+      if (Array.isArray(placementRecord.format_options) || !Array.isArray(placementRecord.format_ids)) continue;
+      const placementId = typeof placementRecord.placement_id === "string" ? placementRecord.placement_id : String(placementIndex);
+      scanScope(
+        {
+          product_id: `${product.product_id}:placement:${placementId}`,
+          name: typeof placementRecord.name === "string" ? placementRecord.name : placementId,
+          description: `Nested placement ${placementId}`,
+          format_ids: placementRecord.format_ids
+        },
+        product.product_id,
+        `products[${product.product_id}].placements[${placementIndex}]`
+      );
+    }
+  }
+  const resolverSignal = createLegacyFormatResolverSignal(requestContext.signal, requestContext.timeoutMs);
+  try {
+    let nextJob = 0;
+    const workerCount = Math.min(requestContext.concurrency, pending.length);
+    await Promise.all(
+      Array.from({ length: workerCount }, async () => {
+        while (nextJob < pending.length) {
+          const job = pending[nextJob++];
+          if (job) await job(resolverSignal.signal);
+        }
+      })
+    );
+  } finally {
+    resolverSignal.dispose();
+  }
+  if (resolutions.size === 0) return converter;
+  return (context) => {
+    const resolved = resolutions.get(legacyFormatResolutionKey(context));
+    if (resolved !== void 0) {
+      if (typeof resolved === "object" && resolved !== null && "resolutionError" in resolved) {
+        throw resolved.resolutionError;
+      }
+      return resolved;
+    }
+    return converter?.(context);
+  };
+}
 const authoredFormatIdsByOwner = /* @__PURE__ */ new WeakMap();
+const STORED_LEGACY_FORMAT_ROUTES = "__adcp_private_legacy_format_routes";
+function assertNoReservedLegacyRouteMetadata(value, path) {
+  const visited = /* @__PURE__ */ new WeakSet();
+  const visit = (current, currentPath) => {
+    if (current === null || typeof current !== "object" || visited.has(current)) return;
+    visited.add(current);
+    for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(current))) {
+      if (!descriptor.enumerable || !("value" in descriptor)) continue;
+      const childPath = Array.isArray(current) ? `${currentPath}[${key}]` : `${currentPath}.${key}`;
+      if (key === STORED_LEGACY_FORMAT_ROUTES) {
+        throw new AdcpError("INVALID_REQUEST", {
+          message: "get_products returned a field reserved for SDK-private route persistence.",
+          field: childPath
+        });
+      }
+      visit(descriptor.value, childPath);
+    }
+  };
+  visit(value, path);
+}
+function captureStoredLegacyFormatRoutes(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const record = value;
+  const formatIds = authoredFormatIdsByOwner.get(record);
+  const placements = Array.isArray(record.placements) ? record.placements.map((placement) => captureStoredLegacyFormatRoutes(placement) ?? null) : void 0;
+  if (!formatIds && !placements?.some(Boolean)) return void 0;
+  return {
+    ...formatIds && { formatIds: formatIds.map((ref) => cloneWireData(ref)) },
+    ...placements?.some(Boolean) && { placements }
+  };
+}
+function restoreStoredLegacyFormatRoutes(value, routes) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || routes === null || typeof routes !== "object" || Array.isArray(routes)) {
+    return;
+  }
+  const record = value;
+  const routeRecord = routes;
+  if (Array.isArray(routeRecord.formatIds) && routeRecord.formatIds.length > 0 && routeRecord.formatIds.every((ref) => isValidStoredLegacyFormatRef(ref))) {
+    authoredFormatIdsByOwner.set(
+      record,
+      routeRecord.formatIds.map((ref) => cloneWireData(ref))
+    );
+  }
+  if (Array.isArray(record.placements) && Array.isArray(routeRecord.placements)) {
+    const count = Math.min(record.placements.length, routeRecord.placements.length);
+    for (let index = 0; index < count; index++) {
+      restoreStoredLegacyFormatRoutes(record.placements[index], routeRecord.placements[index]);
+    }
+  }
+}
+function isValidStoredLegacyFormatRef(value) {
+  if (legacyFormatRefKey(value) === void 0) return false;
+  const ref = value;
+  if (ref.agent_url === "" || ref.id === "") return false;
+  for (const field of ["width", "height", "duration_ms"]) {
+    const fieldValue = ref[field];
+    if (fieldValue !== void 0 && (!Number.isInteger(fieldValue) || fieldValue <= 0)) return false;
+  }
+  return true;
+}
+function getHydratedLegacyFormatIds(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const refs = authoredFormatIdsByOwner.get(value);
+  return refs?.map((ref) => cloneWireData(ref));
+}
 const resolvedLegacyDropDiagnosticsByResponse = /* @__PURE__ */ new WeakMap();
 function ownArrayDataValues(value) {
   const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
@@ -950,7 +1274,6 @@ function warnIfTruncatedMultiIdResponse(toolName, idFieldName, requestedIds, res
   );
 }
 function createAdcpServerFromPlatform(platform, opts) {
-  validatePlatform(platform);
   const runtimeLegacyOptions = opts;
   const legacyHandlers = {
     mediaBuy: opts.legacyHandlers?.mediaBuy ?? runtimeLegacyOptions.mediaBuy,
@@ -958,9 +1281,21 @@ function createAdcpServerFromPlatform(platform, opts) {
     governance: opts.legacyHandlers?.governance ?? runtimeLegacyOptions.governance,
     brandRights: opts.legacyHandlers?.brandRights ?? runtimeLegacyOptions.brandRights
   };
+  validatePlatform(platform, {
+    creative: legacyHandlers.creative,
+    campaignGovernance: legacyHandlers.governance,
+    brandRights: legacyHandlers.brandRights
+  });
   {
     const specialisms = platform.capabilities.specialisms;
-    const issues = validateSpecialismRequiredTools(platform, specialisms);
+    const effectiveSpecialismSurface = {
+      ...platform,
+      mediaBuy: legacyHandlers.mediaBuy,
+      creative: platform.creative ?? legacyHandlers.creative,
+      governance: legacyHandlers.governance,
+      brandRights: platform.brandRights ?? legacyHandlers.brandRights
+    };
+    const issues = validateSpecialismRequiredTools(effectiveSpecialismSurface, specialisms);
     if (issues.length > 0) {
       const messages = issues.map(formatSpecialismIssue);
       if (opts.strictSpecialismValidation === true) {
@@ -1119,6 +1454,8 @@ function createAdcpServerFromPlatform(platform, opts) {
   };
   const adopterCreative = platform.capabilities.creative;
   const adopterAccount = platform.capabilities.account;
+  const adopterExtensionsSupported = platform.capabilities.extensions_supported;
+  const adopterCapabilityExt = platform.capabilities.ext;
   const adopterOverrides = platform.capabilities.overrides;
   const adopterSupportedVersions = platform.capabilities.supported_versions;
   const hasOverridesObject = hasOverridesProjection || adopterOverrides !== void 0;
@@ -1132,6 +1469,10 @@ function createAdcpServerFromPlatform(platform, opts) {
     },
     ...adopterCreative !== void 0 && { creative: adopterCreative },
     ...adopterAccount !== void 0 && { account: adopterAccount },
+    ...adopterExtensionsSupported !== void 0 && {
+      extensions_supported: [...adopterExtensionsSupported]
+    },
+    ...adopterCapabilityExt !== void 0 && { ext: adopterCapabilityExt },
     ...adopterSupportedVersions !== void 0 && {
       supported_versions: [...adopterSupportedVersions]
     },
@@ -1305,6 +1646,21 @@ function createAdcpServerFromPlatform(platform, opts) {
         opts.mediaBuyStore,
         opts.proposalStore,
         opts.legacyCreativeFormatConverter,
+        opts.legacyCreativeFormatResolver,
+        {
+          timeoutMs: legacyFormatResolverLimit(
+            opts.legacyCreativeFormatResolverTimeoutMs,
+            DEFAULT_LEGACY_FORMAT_RESOLVER_TIMEOUT_MS,
+            "legacyCreativeFormatResolverTimeoutMs",
+            MAX_LEGACY_FORMAT_RESOLVER_TIMEOUT_MS
+          ),
+          concurrency: legacyFormatResolverLimit(
+            opts.legacyCreativeFormatResolverConcurrency,
+            DEFAULT_LEGACY_FORMAT_RESOLVER_CONCURRENCY,
+            "legacyCreativeFormatResolverConcurrency",
+            MAX_LEGACY_FORMAT_RESOLVER_CONCURRENCY
+          )
+        },
         opts.canonicalFormatLegacyResolver,
         defaultCreativeWireMode
       ),
@@ -2376,8 +2732,15 @@ async function autoStoreResources(store, accountId, kind, resources, idField, lo
       continue;
     }
     const ctxMeta = obj["ctx_metadata"];
-    const { ctx_metadata: _stripped, ...wireResource } = obj;
+    const {
+      ctx_metadata: _stripped,
+      [STORED_LEGACY_FORMAT_ROUTES]: _reservedRouteMetadata,
+      ...wireResource
+    } = obj;
     void _stripped;
+    void _reservedRouteMetadata;
+    const legacyFormatRoutes = kind === "product" ? captureStoredLegacyFormatRoutes(obj) : void 0;
+    if (legacyFormatRoutes) wireResource[STORED_LEGACY_FORMAT_ROUTES] = legacyFormatRoutes;
     try {
       await store.setResource(accountId, kind, id, wireResource, ctxMeta);
     } catch (err) {
@@ -2451,7 +2814,10 @@ async function hydratePackagesWithProducts(store, accountId, packages, logger, l
     if (!entry?.resource || typeof entry.resource !== "object") continue;
     let hydrated;
     try {
-      hydrated = asCanonicalSemanticServerRequest(entry.resource, "hydrate_product", legacyFormatConverter);
+      const storedResource = entry.resource;
+      const { [STORED_LEGACY_FORMAT_ROUTES]: storedLegacyFormatRoutes, ...resource } = storedResource;
+      hydrated = asCanonicalSemanticServerRequest(resource, "hydrate_product", legacyFormatConverter);
+      restoreStoredLegacyFormatRoutes(hydrated, storedLegacyFormatRoutes);
     } catch {
       logger.warn(
         `[adcp/decisioning] auto-hydrate product:${productId} skipped: stored creative format has no canonical representation`
@@ -2804,7 +3170,7 @@ function buildProposalNegotiationHandlers(platform, taskRegistry, taskWebhookEmi
     }
   };
 }
-function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observability, logger, pushOpts, ctxFor, ctxMetadataStore, mediaBuyStore, proposalStore, legacyFormatConverter, canonicalFormatLegacyResolver, creativeWireMode) {
+function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observability, logger, pushOpts, ctxFor, ctxMetadataStore, mediaBuyStore, proposalStore, legacyFormatConverter, legacyFormatResolver, legacyFormatResolverOptions, canonicalFormatLegacyResolver, creativeWireMode) {
   const sales = platform.sales;
   const lifecycle = platform.mediaBuyLifecycle;
   const getMediaBuyDelivery = lifecycle?.getMediaBuyDelivery ?? sales?.getMediaBuyDelivery;
@@ -2963,7 +3329,22 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
               result = await sales.getProducts(canonicalParams, reqCtx);
             }
             const projectProducts = async (terminalResult) => {
-              const canonicalResult = asCanonicalProductResponse(terminalResult, legacyFormatConverter);
+              const preparedProjection = preparePerProductProjectionCatalogs(terminalResult, legacyFormatConverter);
+              const requestLegacyFormatConverter = await resolveLegacyProductFormats(
+                preparedProjection.response,
+                preparedProjection.converter,
+                legacyFormatResolver,
+                {
+                  ...ctx.servedAdcpVersion !== void 0 && { servedAdcpVersion: ctx.servedAdcpVersion },
+                  ...reqCtx.account?.id !== void 0 && { accountId: reqCtx.account.id },
+                  ...ctx.signal !== void 0 && { signal: ctx.signal },
+                  ...legacyFormatResolverOptions
+                }
+              );
+              const canonicalResult = asCanonicalProductResponse(
+                preparedProjection.response,
+                requestLegacyFormatConverter
+              );
               await autoStoreResources(
                 ctxMetadataStore,
                 reqCtx.account?.id,
@@ -3153,6 +3534,20 @@ function buildMediaBuyHandlers(platform, taskRegistry, taskWebhookEmit, observab
           logger,
           legacyFormatConverter
         );
+        await hydratePackagesWithProducts(
+          ctxMetadataStore,
+          reqCtx.account?.id,
+          params.packages,
+          logger,
+          legacyFormatConverter
+        );
+        await hydratePackagesWithProducts(
+          ctxMetadataStore,
+          reqCtx.account?.id,
+          params.new_packages,
+          logger,
+          legacyFormatConverter
+        );
         if (proposalStore) {
           const record = await maybeHydrateRecipesForMediaBuyId({
             mediaBuyId: media_buy_id,
@@ -4309,6 +4704,7 @@ export {
   INTENTIONALLY_UNHYDRATED_ENTITIES,
   _resetMergeSeamDedupe,
   createAdcpServerFromPlatform,
-  getAllAdcpMigrations
+  getAllAdcpMigrations,
+  getHydratedLegacyFormatIds
 };
 //# sourceMappingURL=from-platform.mjs.map