@tokenoftrust/storefront-runner 4.10.1 → 4.11.0

package/agency-kit/tools/lib/analytics-declaration.mjs

@@ -10,8 +10,9 @@
  * input; `agency-kit/tools/lib/fixtures/analytics-declarations.json` is run through both, so a
  * drift on either side fails a test.
  *
- * Messages carry no value from the file — never an id, never a key's value — only the field path
- * and a fixed explanation, so a finding is safe to print, log or forward.
+ * Messages carry no value from the file — never an id, never a key's value, never an unrecognized
+ * key — only the field path and a fixed explanation, so a finding is safe to print, log or forward.
+ * An unrecognized key is anchored by its position among the rejected keys (`$property[0]`).
  *
  * Pure: callers pass the file's text. `packages/cli/src/analytics-declaration.mjs` is a
  * byte-identical copy (a test pins it).
@@ -77,6 +78,17 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+/**
+ * The anchor for the `ordinal`-th rejected key of an object. A rejected key is untrusted text, so
+ * the path names its position among the rejected keys, never the key.
+ * @param {string} base
+ * @param {number} ordinal
+ */
+function rejectedKeyPath(base, ordinal) {
+  const anchor = `$property[${ordinal}]`;
+  return base ? `${base}.${anchor}` : anchor;
+}
+
 /**
  * @param {Record<string, unknown>} obj
  * @param {readonly string[]} allowed
@@ -84,9 +96,11 @@ function isPlainObject(value) {
  * @param {AnalyticsViolation[]} out
  */
 function unknownKeys(obj, allowed, base, out) {
+  let ordinal = 0;
   for (const key of Object.keys(obj)) {
     if (allowed.includes(key) || ANNOTATION_KEYS.includes(key)) continue;
-    out.push({ path: base ? `${base}.${key}` : key, code: "unknown_field" });
+    out.push({ path: rejectedKeyPath(base, ordinal), code: "unknown_field" });
+    ordinal += 1;
   }
 }
 
@@ -100,12 +114,14 @@ function unknownKeys(obj, allowed, base, out) {
 function stageIdViolations(ids, adapter, base, out) {
   /** @type {Map<string, string[]>} */
   const valid = new Map();
+  let rejectedStages = 0;
   for (const [stage, raw] of Object.entries(ids)) {
-    const at = `${base}.ids.${stage}`;
     if (!ANALYTICS_STAGES.includes(stage)) {
-      out.push({ path: at, code: "unknown_enum" });
+      out.push({ path: rejectedKeyPath(`${base}.ids`, rejectedStages), code: "unknown_enum" });
+      rejectedStages += 1;
       continue;
     }
+    const at = `${base}.ids.${stage}`;
     if (!Array.isArray(raw)) {
       out.push({ path: at, code: "type" });
       continue;

package/apps/storefront/src/lib/integrations/integration/stageDestinationIds.ts

@@ -66,16 +66,19 @@ export function parseStageDestinationIds(
   const details: StageDestinationIdsError["details"] = [];
   const value: DestinationIdsByEnvironment = {};
 
+  let rejectedStages = 0;
   for (const [stage, raw] of entries) {
-    const path = `${base}.${stage}`;
     if (!(ADAPTER_CONFIG_STAGES as readonly string[]).includes(stage)) {
+      // An unrecognized stage key is untrusted text: anchor it by position, never by name.
       details.push({
-        path,
+        path: `${base}.$property[${rejectedStages}]`,
         code: "unknown_enum",
         message: `Stage must be one of: ${ADAPTER_CONFIG_STAGES.join(", ")}.`,
       });
+      rejectedStages += 1;
       continue;
     }
+    const path = `${base}.${stage}`;
     if (!Array.isArray(raw)) {
       details.push({
         path,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokenoftrust/storefront-runner",
-  "version": "4.10.1",
+  "version": "4.11.0",
   "license": "SEE LICENSE IN LICENSE",
   "description": "World-shareable storefront runner: multi-tenant renderer on Astro/Cloudflare. No control plane.",
   "packageManager": "pnpm@11.9.0",

package/packages/public-runtime/src/integration/platform-adapters.ts

@@ -49,7 +49,7 @@
  * value stays in server custody — never in this browser config.
  */
 import type { ContractResult, ContractViolation } from "./result.js";
-import { Violations, isPlainObject } from "./result.js";
+import { Violations, isPlainObject, rejectedKeyPath } from "./result.js";
 import type { CommerceEventType, CommerceEvent } from "./events.js";
 import { APPROVED_MARKETING_ACTION_NAMES } from "./events.js";
 import type {
@@ -599,9 +599,11 @@ function validateDestinationIds(
   }
 
   const out: DestinationIdsByEnvironment = {};
+  let rejectedStages = 0;
   for (const [key, raw] of Object.entries(value)) {
     if (!(INTEGRATION_ENVIRONMENTS as readonly string[]).includes(key)) {
-      v.add(`ids.${key}`, "unknown_enum", `Unknown environment "${key}"; one of: ${INTEGRATION_ENVIRONMENTS.join(", ")}.`);
+      v.add(rejectedKeyPath("ids", rejectedStages), "unknown_enum", `Unknown environment; one of: ${INTEGRATION_ENVIRONMENTS.join(", ")}.`);
+      rejectedStages += 1;
       continue;
     }
     if (!Array.isArray(raw)) {

package/packages/public-runtime/src/integration/result.ts

@@ -46,6 +46,14 @@ export function joinPath(path: string, key: string): string {
   return path ? `${path}.${key}` : key;
 }
 
+/**
+ * The path of the `ordinal`-th rejected key of the object at `path`. A rejected key is untrusted
+ * text, so the path names its position among the rejected keys (`$property[0]`), never the key.
+ */
+export function rejectedKeyPath(path: string, ordinal: number): string {
+  return joinPath(path, `$property[${ordinal}]`);
+}
+
 export function rejectUnknownKeys(
   obj: Record<string, unknown>,
   allowed: readonly string[],
@@ -53,13 +61,15 @@ export function rejectUnknownKeys(
   path: string,
 ): void {
   const set = new Set([...allowed, ...ANNOTATION_KEYS]);
+  let ordinal = 0;
   for (const key of Object.keys(obj)) {
     if (!set.has(key)) {
       v.add(
-        joinPath(path, key),
+        rejectedKeyPath(path, ordinal),
         "unknown_field",
-        `Unknown field "${key}"; this contract is closed.`,
+        "Unknown field; this contract is closed.",
       );
+      ordinal += 1;
     }
   }
 }