@modainteract/moda-interact-shared 5.6.0 → 5.8.0

package/dist/{chunk-S42O2OCG.js → chunk-SW2AFMT7.js}

@@ -8,18 +8,119 @@ import {
   SemverSchema,
   boundedJson,
   distinct
-} from "./chunk-QVPEX7KY.js";
+} from "./chunk-GCCT2BDE.js";
+import {
+  canonicaliseLanguageTag
+} from "./chunk-4KSODB2R.js";
 import {
   canonicalJson,
   jsonBytes,
   responseContractCanonicalJson
 } from "./chunk-AUS3WQIW.js";
-import {
-  canonicaliseLanguageTag
-} from "./chunk-4KSODB2R.js";
 
-// src/commerce/subset.ts
+// src/commerce/product-facts.ts
 import { z } from "zod";
+import { parseFragment } from "parse5";
+var codePoints = (value) => Array.from(value).length;
+var controls = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/u;
+var label = z.string().min(1).refine((value) => codePoints(value) <= 128 && value === value.trim() && !/[\r\n\t]/u.test(value) && !controls.test(value));
+var status = z.enum(["AVAILABLE", "NOT_PROVIDED", "PARTIAL"]);
+var CommerceProductDescriptionSchema = z.strictObject({ status, text: z.string().refine((value) => codePoints(value) <= 4096 && !controls.test(value)) }).refine((value) => (value.status !== "NOT_PROVIDED" || value.text === "") && (value.status !== "AVAILABLE" || value.text.trim().length > 0));
+var CommerceProductAttributesSchema = z.strictObject({ status, items: z.array(z.strictObject({ name: label, values: z.array(label).max(64) })).max(16) }).refine((value) => (value.status !== "NOT_PROVIDED" || value.items.length === 0) && (value.status !== "AVAILABLE" || value.items.length > 0)).refine((value) => new Set(value.items.map((item) => item.name)).size === value.items.length && value.items.every((item) => new Set(item.values).size === item.values.length));
+function normalizeCommerceProductDescription(source, format) {
+  if (source === null || source === void 0 || source === "") return { status: "NOT_PROVIDED", text: "" };
+  if (typeof source !== "string" || !["PLAIN_TEXT", "HTML"].includes(format)) return { status: "PARTIAL", text: "" };
+  if (new TextEncoder().encode(source).length > 65536) return { status: "PARTIAL", text: "" };
+  let partial = controls.test(source);
+  let text = source;
+  if (format === "HTML") {
+    const lines = [];
+    const boundaries = /* @__PURE__ */ new Set(["br", "p", "div", "li", "ul", "ol", "h1", "h2", "h3", "h4", "h5", "h6", "table", "tr"]);
+    const skip = /* @__PURE__ */ new Set(["script", "style", "template", "noscript"]);
+    const walk = (node) => {
+      if ("tagName" in node && skip.has(node.tagName)) return;
+      const boundary = "tagName" in node && boundaries.has(node.tagName);
+      if (boundary) lines.push("\n");
+      if (node.nodeName === "#text" && "value" in node) lines.push(node.value);
+      if ("childNodes" in node) for (const child of node.childNodes) walk(child);
+      if (boundary && !("tagName" in node && node.tagName === "br")) lines.push("\n");
+    };
+    try {
+      walk(parseFragment(source, { onParseError: () => {
+        partial = true;
+      } }));
+      text = lines.join("");
+    } catch {
+      return { status: "PARTIAL", text: "" };
+    }
+  }
+  partial ||= controls.test(text);
+  text = text.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/gu, "").replace(/\r\n?/gu, "\n").replace(/[^\S\n]+/gu, " ").replace(/\n{3,}/gu, "\n\n").trim();
+  if (codePoints(text) > 4096) {
+    text = Array.from(text).slice(0, 4096).join("");
+    partial = true;
+  }
+  return { status: partial ? "PARTIAL" : text ? "AVAILABLE" : "NOT_PROVIDED", text };
+}
+function normalizeCommerceProductAttributes(source) {
+  if (source === void 0 || source === null) return { status: "NOT_PROVIDED", items: [] };
+  const canonical = source && typeof source === "object" && !Array.isArray(source) ? source : null;
+  const rows = canonical ? canonical.items : source;
+  if (!Array.isArray(rows)) return { status: "PARTIAL", items: [] };
+  let partial = !!canonical && (!["AVAILABLE", "NOT_PROVIDED"].includes(String(canonical.status)) || canonical.status === "NOT_PROVIDED" && rows.length > 0);
+  const items = [];
+  const clean = (raw) => {
+    if (typeof raw !== "string" || controls.test(raw)) return null;
+    const value = raw.replace(/[\r\n\t]/gu, " ").replace(/\s+/gu, " ").trim();
+    return value && codePoints(value) <= 128 ? value : null;
+  };
+  for (const raw of rows) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      partial = true;
+      continue;
+    }
+    const row = raw;
+    const name = clean(row.name);
+    if (!name || !Array.isArray(row.values)) {
+      partial = true;
+      continue;
+    }
+    let item = items.find((value) => value.name === name);
+    if (!item) {
+      if (items.length >= 16) {
+        partial = true;
+        continue;
+      }
+      item = { name, values: [] };
+      items.push(item);
+    }
+    for (const rawValue of row.values) {
+      const value = clean(rawValue);
+      if (!value) {
+        partial = true;
+        continue;
+      }
+      if (item.values.includes(value)) continue;
+      if (item.values.length >= 64) {
+        partial = true;
+        continue;
+      }
+      item.values.push(value);
+    }
+  }
+  return { status: partial ? "PARTIAL" : items.length ? "AVAILABLE" : "NOT_PROVIDED", items };
+}
+function normalizeCommerceProductDescriptionField(source) {
+  if (!source || typeof source !== "object" || Array.isArray(source)) return { status: "PARTIAL", text: "" };
+  const value = source;
+  if (typeof value.text !== "string") return { status: "PARTIAL", text: "" };
+  const normalized = normalizeCommerceProductDescription(value.text, "PLAIN_TEXT");
+  if (!status.safeParse(value.status).success || value.status === "PARTIAL" || value.status === "NOT_PROVIDED" && normalized.text) normalized.status = "PARTIAL";
+  return normalized;
+}
+
+// src/commerce/subset.ts
+import { z as z2 } from "zod";
 var MONEY_PATTERN = "^[0-9]{1,18}(\\.[0-9]{1,6})?$";
 var safeName = (name) => /^[A-Za-z][A-Za-z0-9_]{0,63}$/.test(name) && !["__proto__", "prototype", "constructor"].includes(name);
 var safePath = (path) => path.length <= 256 && path.split(".").every(safeName);
@@ -119,10 +220,10 @@ function validateSubset(value, mode) {
     return false;
   }
 }
-var InputSchemaSchema = z.custom(
+var InputSchemaSchema = z2.custom(
   (v) => validateSubset(v, "input")
 );
-var DetailsSchemaSchema = z.custom(
+var DetailsSchemaSchema = z2.custom(
   (v) => validateSubset(v, "details")
 );
 function matchesSubset(schema, value) {
@@ -146,7 +247,7 @@ function matchesSubset(schema, value) {
 }
 function compileSubset(schema, mode) {
   if (!validateSubset(schema, mode)) throw new TypeError("Unsupported schema");
-  return z.custom((value) => {
+  return z2.custom((value) => {
     try {
       return jsonBytes(value) <= (mode === "details" ? 16384 : 131072) && matchesSubset(schema, value);
     } catch {
@@ -156,7 +257,7 @@ function compileSubset(schema, mode) {
 }
 
 // src/commerce/purpose-output.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var CANONICAL_PATTERNS = [
   "^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\\.[0-9]+)?Z(?![\\s\\S])",
   "^[0-9]{1,18}(\\.[0-9]{1,6})?$",
@@ -223,7 +324,7 @@ function validateCommercePurposeOutputSchema(value) {
     return false;
   }
 }
-var CommercePurposeOutputSchemaSchema = z2.custom(validateCommercePurposeOutputSchema);
+var CommercePurposeOutputSchemaSchema = z3.custom(validateCommercePurposeOutputSchema);
 function matches(schema, value) {
   if (schema.anyOf) return schema.anyOf.some((branch) => matches(branch, value));
   const nullable = Array.isArray(schema.type);
@@ -254,7 +355,7 @@ function matches(schema, value) {
 function compileCommercePurposeOutputSchema(raw) {
   if (!validateCommercePurposeOutputSchema(raw)) throw new TypeError("Unsupported purpose output schema");
   const snapshot = structuredClone(raw);
-  return z2.custom((value) => {
+  return z3.custom((value) => {
     try {
       return jsonBytes(value) <= 32768 && matches(snapshot, value);
     } catch {
@@ -264,39 +365,39 @@ function compileCommercePurposeOutputSchema(raw) {
 }
 
 // src/commerce/external.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var utf8 = (value, maximum) => new TextEncoder().encode(value).length <= maximum;
-var scalar = z3.union([z3.string().refine((value) => utf8(value, 2048)), z3.number().finite(), z3.boolean()]);
+var scalar = z4.union([z4.string().refine((value) => utf8(value, 2048)), z4.number().finite(), z4.boolean()]);
 var ExternalQueryValueSchema = scalar;
-var scalarOrNull = z3.union([scalar, z3.null()]);
-var record2 = (item, max) => z3.record(z3.string().refine(safeName), item).refine((value) => Object.keys(value).length <= max);
-var ExternalQueryMappingSchema = z3.union([
-  z3.strictObject({ input: z3.string().refine(safeName), omitIfMissing: z3.literal(true).optional() }),
-  z3.strictObject({ literal: scalar })
+var scalarOrNull = z4.union([scalar, z4.null()]);
+var record2 = (item, max) => z4.record(z4.string().refine(safeName), item).refine((value) => Object.keys(value).length <= max);
+var ExternalQueryMappingSchema = z4.union([
+  z4.strictObject({ input: z4.string().refine(safeName), omitIfMissing: z4.literal(true).optional() }),
+  z4.strictObject({ literal: scalar })
 ]);
 var ExternalQueryMappingsSchema = record2(ExternalQueryMappingSchema, 32).superRefine((value, ctx) => {
   const reserved = /^(authorization|cookie|set-cookie|host|x-api-key|api_key|apikey|access_token|token|secret|password)$/i;
   for (const key of Object.keys(value)) if (reserved.test(key)) ctx.addIssue({ code: "custom", path: [key], message: "Reserved query key" });
 });
-var ExternalPathSchema = z3.string().max(1024).refine(
+var ExternalPathSchema = z4.string().max(1024).refine(
   (value) => utf8(value, 1024) && /^\/(?:[A-Za-z0-9._~-]+\/)*[A-Za-z0-9._~-]*\/?$/.test(value) && !value.includes("//") && !value.includes("%") && !value.includes("\\") && !value.includes("?") && !value.includes("#") && !value.includes("{") && !value.includes("}") && value.split("/").every((segment) => segment !== "." && segment !== "..")
 );
-var mediaType = z3.string().min(1).max(128).refine((value) => value === value.toLowerCase() && /^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(value));
+var mediaType = z4.string().min(1).max(128).refine((value) => value === value.toLowerCase() && /^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(value));
 var jsonMime = (value) => value === "application/json" || /^application\/[a-z0-9!#$&^_.+-]+\+json$/.test(value);
 var textMime = (value) => /^text\/[a-z0-9!#$&^_.+-]+$/.test(value) || value === "application/xml" || /^application\/[a-z0-9!#$&^_.+-]+\+xml$/.test(value) || jsonMime(value);
-var ExternalResponseFormatSchema = z3.strictObject({ mode: z3.enum(["JSON", "TEXT"]), mediaTypes: z3.array(mediaType).min(1).max(8).refine((values) => new Set(values).size === values.length) }).refine((value) => value.mediaTypes.every(value.mode === "JSON" ? jsonMime : textMime));
-var FieldProjectionSchema = record2(z3.strictObject({ path: z3.string().refine(safePath), omitIfMissing: z3.literal(true).optional() }), 32).refine((value) => Object.keys(value).length >= 1);
-var ResponseFilterSchema = z3.discriminatedUnion("op", [
-  z3.strictObject({ path: z3.string().refine(safePath), op: z3.enum(["EQ", "NE", "GT", "GTE", "LT", "LTE", "CONTAINS", "STARTS_WITH"]), value: scalarOrNull }),
-  z3.strictObject({ path: z3.string().refine(safePath), op: z3.literal("IN"), values: z3.array(scalarOrNull).min(1).max(20) })
+var ExternalResponseFormatSchema = z4.strictObject({ mode: z4.enum(["JSON", "TEXT"]), mediaTypes: z4.array(mediaType).min(1).max(8).refine((values) => new Set(values).size === values.length) }).refine((value) => value.mediaTypes.every(value.mode === "JSON" ? jsonMime : textMime));
+var FieldProjectionSchema = record2(z4.strictObject({ path: z4.string().refine(safePath), omitIfMissing: z4.literal(true).optional() }), 32).refine((value) => Object.keys(value).length >= 1);
+var ResponseFilterSchema = z4.discriminatedUnion("op", [
+  z4.strictObject({ path: z4.string().refine(safePath), op: z4.enum(["EQ", "NE", "GT", "GTE", "LT", "LTE", "CONTAINS", "STARTS_WITH"]), value: scalarOrNull }),
+  z4.strictObject({ path: z4.string().refine(safePath), op: z4.literal("IN"), values: z4.array(scalarOrNull).min(1).max(20) })
 ]);
-var visualObject = z3.strictObject({ kind: z3.literal("OBJECT"), fields: FieldProjectionSchema });
-var visualList = z3.strictObject({ kind: z3.literal("LIST"), fields: FieldProjectionSchema, filters: z3.array(ResponseFilterSchema).max(8), sort: z3.union([z3.null(), z3.strictObject({ path: z3.string().refine(safePath), direction: z3.enum(["ASC", "DESC"]) })]), limit: z3.int().min(1).max(20) });
-var VisualResponseProcessingSchema = z3.union([visualObject, visualList]);
-var ResponseProcessingSchema = z3.union([VisualResponseProcessingSchema, z3.strictObject({ kind: z3.literal("JAVASCRIPT"), runtimeVersion: z3.literal("quickjs-sync.v1"), source: z3.string().min(1).refine((value) => utf8(value, 16384)) })]);
-var TransformResponseSchema = z3.strictObject({ status: z3.int().min(200).max(299), contentType: z3.string().min(1).max(128), bodyText: z3.string().refine((value) => utf8(value, 262144)), json: z3.union([z3.null(), z3.json()]) });
-var TransformSampleSchema = z3.strictObject({ status: z3.int().min(200).max(299), contentType: z3.string().min(1).max(128), bodyText: z3.string().refine((value) => utf8(value, 262144)) }).refine((value) => jsonBytes(value) <= 524288);
-var boundedValues = z3.custom((value) => {
+var visualObject = z4.strictObject({ kind: z4.literal("OBJECT"), fields: FieldProjectionSchema });
+var visualList = z4.strictObject({ kind: z4.literal("LIST"), fields: FieldProjectionSchema, filters: z4.array(ResponseFilterSchema).max(8), sort: z4.union([z4.null(), z4.strictObject({ path: z4.string().refine(safePath), direction: z4.enum(["ASC", "DESC"]) })]), limit: z4.int().min(1).max(20) });
+var VisualResponseProcessingSchema = z4.union([visualObject, visualList]);
+var ResponseProcessingSchema = z4.union([VisualResponseProcessingSchema, z4.strictObject({ kind: z4.literal("JAVASCRIPT"), runtimeVersion: z4.literal("quickjs-sync.v1"), source: z4.string().min(1).refine((value) => utf8(value, 16384)) })]);
+var TransformResponseSchema = z4.strictObject({ status: z4.int().min(200).max(299), contentType: z4.string().min(1).max(128), bodyText: z4.string().refine((value) => utf8(value, 262144)), json: z4.union([z4.null(), z4.json()]) });
+var TransformSampleSchema = z4.strictObject({ status: z4.int().min(200).max(299), contentType: z4.string().min(1).max(128), bodyText: z4.string().refine((value) => utf8(value, 262144)) }).refine((value) => jsonBytes(value) <= 524288);
+var boundedValues = z4.custom((value) => {
   const visit = (node, depth) => depth <= 20 && (node === null || typeof node === "string" || typeof node === "boolean" || typeof node === "number" && Number.isFinite(node) || Array.isArray(node) && node.every((child) => visit(child, depth + 1)) || !!node && typeof node === "object" && !Array.isArray(node) && Object.getPrototypeOf(node) === Object.prototype && Object.entries(node).every(([key, child]) => !["__proto__", "prototype", "constructor"].includes(key) && visit(child, depth + 1)));
   try {
     return !!value && typeof value === "object" && !Array.isArray(value) && visit(value, 1) && jsonBytes(value) <= 49152;
@@ -304,24 +405,24 @@ var boundedValues = z3.custom((value) => {
     return false;
   }
 });
-var ExternalHttpResultDataSchema = z3.strictObject({ source: z3.literal("EXTERNAL_HTTP"), connectionRevisionId: IdSchema, observedAt: DateSchema, values: boundedValues });
-var ConnectionRevisionViewSchema = z3.strictObject({ id: IdSchema, connectionId: IdSchema, revisionNumber: z3.int().positive(), origin: z3.string().min(1).max(2048), scope: z3.enum(["PLATFORM", "PER_SHOP"]), authMode: z3.enum(["NONE", "BEARER", "API_KEY"]), authHeader: z3.string().min(1).max(128).nullable(), documentation: z3.string().max(16e3), createdAt: z3.iso.datetime({ offset: false }) });
-var ConnectionViewSchema = z3.strictObject({ id: IdSchema, key: z3.string().regex(/^[a-z][a-z0-9_]{0,127}$/), displayName: z3.string().min(1).max(255), description: z3.string().max(4096), enabled: z3.boolean(), editVersion: z3.int().positive(), revisions: z3.array(ConnectionRevisionViewSchema) });
-var CredentialStatusSchema = z3.strictObject({ connectionRevisionId: IdSchema, shopId: IdSchema.nullable(), configured: z3.boolean(), editVersion: z3.int().positive().nullable(), updatedAt: z3.iso.datetime({ offset: false }).nullable() });
-var ConnectionCommandSchema = z3.strictObject({ operationId: IdSchema, reason: z3.string().trim().min(1).max(1e3) });
-var RevisionInputSchema = z3.strictObject({ origin: z3.string().min(1).max(2048), scope: z3.enum(["PLATFORM", "PER_SHOP"]), authMode: z3.enum(["NONE", "BEARER", "API_KEY"]), authHeader: z3.string().min(1).max(128).nullable(), documentation: z3.string().max(16e3) });
-var ConnectionIssueSchema = z3.strictObject({ path: z3.string().max(256), message: z3.string().min(1).max(512) });
-var ConnectionResultSchema = (value) => z3.discriminatedUnion("kind", [
-  z3.strictObject({ kind: z3.literal("ok"), value }),
-  z3.strictObject({ kind: z3.literal("not-found") }),
-  z3.strictObject({ kind: z3.literal("forbidden") }),
-  z3.strictObject({ kind: z3.literal("unavailable") }),
-  z3.strictObject({ kind: z3.literal("invalid"), issues: z3.array(ConnectionIssueSchema).max(32) }),
-  z3.strictObject({ kind: z3.literal("conflict"), code: z3.enum(["STALE_CAS", "CONFLICTING_REPLAY"]) })
+var ExternalHttpResultDataSchema = z4.strictObject({ source: z4.literal("EXTERNAL_HTTP"), connectionRevisionId: IdSchema, observedAt: DateSchema, values: boundedValues });
+var ConnectionRevisionViewSchema = z4.strictObject({ id: IdSchema, connectionId: IdSchema, revisionNumber: z4.int().positive(), origin: z4.string().min(1).max(2048), scope: z4.enum(["PLATFORM", "PER_SHOP"]), authMode: z4.enum(["NONE", "BEARER", "API_KEY"]), authHeader: z4.string().min(1).max(128).nullable(), documentation: z4.string().max(16e3), createdAt: z4.iso.datetime({ offset: false }) });
+var ConnectionViewSchema = z4.strictObject({ id: IdSchema, key: z4.string().regex(/^[a-z][a-z0-9_]{0,127}$/), displayName: z4.string().min(1).max(255), description: z4.string().max(4096), enabled: z4.boolean(), editVersion: z4.int().positive(), revisions: z4.array(ConnectionRevisionViewSchema) });
+var CredentialStatusSchema = z4.strictObject({ connectionRevisionId: IdSchema, shopId: IdSchema.nullable(), configured: z4.boolean(), editVersion: z4.int().positive().nullable(), updatedAt: z4.iso.datetime({ offset: false }).nullable() });
+var ConnectionCommandSchema = z4.strictObject({ operationId: IdSchema, reason: z4.string().trim().min(1).max(1e3) });
+var RevisionInputSchema = z4.strictObject({ origin: z4.string().min(1).max(2048), scope: z4.enum(["PLATFORM", "PER_SHOP"]), authMode: z4.enum(["NONE", "BEARER", "API_KEY"]), authHeader: z4.string().min(1).max(128).nullable(), documentation: z4.string().max(16e3) });
+var ConnectionIssueSchema = z4.strictObject({ path: z4.string().max(256), message: z4.string().min(1).max(512) });
+var ConnectionResultSchema = (value) => z4.discriminatedUnion("kind", [
+  z4.strictObject({ kind: z4.literal("ok"), value }),
+  z4.strictObject({ kind: z4.literal("not-found") }),
+  z4.strictObject({ kind: z4.literal("forbidden") }),
+  z4.strictObject({ kind: z4.literal("unavailable") }),
+  z4.strictObject({ kind: z4.literal("invalid"), issues: z4.array(ConnectionIssueSchema).max(32) }),
+  z4.strictObject({ kind: z4.literal("conflict"), code: z4.enum(["STALE_CAS", "CONFLICTING_REPLAY"]) })
 ]);
 
 // src/commerce/definitions.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 import { gt } from "semver";
 
 // src/commerce/definition-size.ts
@@ -362,19 +463,19 @@ var definitionFitsStorage = (value) => {
 var DEFINITION_SIZE_MESSAGE = "Definition exceeds the 65536-byte jsonb text limit";
 
 // src/commerce/definitions.ts
-var ToolNameSchema = z4.string().regex(/^[a-z][a-z0-9_]{0,127}$/).refine((n) => n !== "finalResponse");
-var CommerceExecutionPurposeSchema = z4.literal("INITIAL_RECOVERY_OUTREACH");
-var CommercePurposeProfileSchema = z4.strictObject({
+var ToolNameSchema = z5.string().regex(/^[a-z][a-z0-9_]{0,127}$/).refine((n) => n !== "finalResponse");
+var CommerceExecutionPurposeSchema = z5.literal("INITIAL_RECOVERY_OUTREACH");
+var CommercePurposeProfileSchema = z5.strictObject({
   purpose: CommerceExecutionPurposeSchema,
   featureId: IdSchema,
   releaseId: IdSchema,
-  behaviourPrompt: z4.string().refine((value) => new TextEncoder().encode(value).length <= 32768),
-  capabilities: z4.array(z4.strictObject({
+  behaviourPrompt: z5.string().refine((value) => new TextEncoder().encode(value).length <= 32768),
+  capabilities: z5.array(z5.strictObject({
     capabilityId: IdSchema,
     toolId: IdSchema,
     revisionId: IdSchema,
     name: ToolNameSchema,
-    position: z4.number().int().nonnegative(),
+    position: z5.number().int().nonnegative(),
     inputSchema: InputSchemaSchema,
     outputSchema: CommercePurposeOutputSchemaSchema
   })).min(1, { message: "PROFILE_EMPTY" }).max(32)
@@ -396,52 +497,52 @@ var CommercePurposeProfileSchema = z4.strictObject({
 function requireCommercePurposeProfile(raw) {
   return CommercePurposeProfileSchema.parse(raw);
 }
-var PublishedGrantedToolSchema = z4.strictObject({
+var PublishedGrantedToolSchema = z5.strictObject({
   toolId: IdSchema,
   toolRevisionId: IdSchema,
   toolName: ToolNameSchema,
   definitionVersion: SemverSchema,
-  capabilityKeys: z4.array(IdSchema).min(1).max(32).refine((v) => distinct(v) && v.join("\0") === [...v].sort().join("\0"))
+  capabilityKeys: z5.array(IdSchema).min(1).max(32).refine((v) => distinct(v) && v.join("\0") === [...v].sort().join("\0"))
 });
-var PublishedToolDescriptorSchema = z4.strictObject({
+var PublishedToolDescriptorSchema = z5.strictObject({
   toolId: IdSchema,
   toolRevisionId: IdSchema,
   name: ToolNameSchema,
   definitionVersion: SemverSchema,
-  description: z4.string().min(1).max(4096),
+  description: z5.string().min(1).max(4096),
   inputSchema: InputSchemaSchema
 });
-var CommerceBuiltInToolNameSchema = z4.enum([
+var CommerceBuiltInToolNameSchema = z5.enum([
   "commerce_get_discount_options",
   "commerce_get_discount_details"
 ]).meta({ maxLength: 29 });
-var CommerceBuiltInToolGrantSchema = z4.strictObject({
-  kind: z4.enum(["BUILT_IN"]).meta({ maxLength: 8 }),
+var CommerceBuiltInToolGrantSchema = z5.strictObject({
+  kind: z5.enum(["BUILT_IN"]).meta({ maxLength: 8 }),
   toolName: CommerceBuiltInToolNameSchema,
-  definitionVersion: z4.enum(["2.0.0"]).meta({ maxLength: 5 })
+  definitionVersion: z5.enum(["2.0.0"]).meta({ maxLength: 5 })
 });
-var CommerceBuiltInToolDescriptorSchema = z4.strictObject({
-  kind: z4.enum(["BUILT_IN"]).meta({ maxLength: 8 }),
+var CommerceBuiltInToolDescriptorSchema = z5.strictObject({
+  kind: z5.enum(["BUILT_IN"]).meta({ maxLength: 8 }),
   name: CommerceBuiltInToolNameSchema,
-  definitionVersion: z4.enum(["2.0.0"]).meta({ maxLength: 5 }),
-  description: z4.string().min(1).max(4096),
+  definitionVersion: z5.enum(["2.0.0"]).meta({ maxLength: 5 }),
+  description: z5.string().min(1).max(4096),
   inputSchema: InputSchemaSchema
 });
-var GrantedToolSchema = z4.union([PublishedGrantedToolSchema, CommerceBuiltInToolGrantSchema]);
-var ToolDescriptorSchema = z4.union([PublishedToolDescriptorSchema, CommerceBuiltInToolDescriptorSchema]);
-var GrantedToolsSchema = z4.array(GrantedToolSchema).max(32).refine((values) => {
+var GrantedToolSchema = z5.union([PublishedGrantedToolSchema, CommerceBuiltInToolGrantSchema]);
+var ToolDescriptorSchema = z5.union([PublishedToolDescriptorSchema, CommerceBuiltInToolDescriptorSchema]);
+var GrantedToolsSchema = z5.array(GrantedToolSchema).max(32).refine((values) => {
   const published = values.filter((value) => !("kind" in value));
   return distinct(values.map((value) => value.toolName)) && distinct(published.map((value) => value.toolId));
 });
 var isBuiltInTool = (value) => "kind" in value && value.kind === "BUILT_IN";
-var MappingSchema = z4.union([
-  z4.strictObject({
-    input: z4.string().refine(safeName),
-    omitIfMissing: z4.literal(true).optional()
+var MappingSchema = z5.union([
+  z5.strictObject({
+    input: z5.string().refine(safeName),
+    omitIfMissing: z5.literal(true).optional()
   }),
-  z4.strictObject({ literal: boundedJson(8192) })
+  z5.strictObject({ literal: boundedJson(8192) })
 ]);
-var MappingsSchema = z4.record(z4.string().refine(safeName), MappingSchema).refine((v) => Object.keys(v).length <= 32);
+var MappingsSchema = z5.record(z5.string().refine(safeName), MappingSchema).refine((v) => Object.keys(v).length <= 32);
 var POLICY_OPERATIONS = [
   "taxonomy.resolveCategories",
   "products.search",
@@ -455,15 +556,15 @@ var POLICY_OPERATIONS = [
   "products.findQualifying",
   "products.findSimilar"
 ];
-var ExternalHttpExecutionSchema = z4.strictObject({
-  kind: z4.literal("EXTERNAL_HTTP"),
-  executorVersion: z4.literal("1.0.0"),
+var ExternalHttpExecutionSchema = z5.strictObject({
+  kind: z5.literal("EXTERNAL_HTTP"),
+  executorVersion: z5.literal("1.0.0"),
   connectionRevisionId: IdSchema,
-  method: z4.literal("GET"),
+  method: z5.literal("GET"),
   path: ExternalPathSchema,
   query: ExternalQueryMappingsSchema,
   responseFormat: ExternalResponseFormatSchema,
-  resultPath: z4.string().refine((value) => value === "" || safePath(value)),
+  resultPath: z5.string().refine((value) => value === "" || safePath(value)),
   responseProcessing: ResponseProcessingSchema,
   resultSchema: DetailsSchemaSchema
 }).superRefine((value, ctx) => {
@@ -472,21 +573,21 @@ var ExternalHttpExecutionSchema = z4.strictObject({
   if (value.responseProcessing.kind !== "JAVASCRIPT" && value.responseFormat.mode !== "JSON")
     ctx.addIssue({ code: "custom", path: ["responseFormat", "mode"], message: "Visual processing requires JSON" });
 });
-var CommerceExecutionSchema = z4.discriminatedUnion("kind", [
-  z4.strictObject({
-    kind: z4.literal("SHOPIFY_STOREFRONT_QUERY"),
-    executorVersion: z4.literal("1.0.0"),
-    apiVersion: z4.literal("2026-07"),
+var CommerceExecutionSchema = z5.discriminatedUnion("kind", [
+  z5.strictObject({
+    kind: z5.literal("SHOPIFY_STOREFRONT_QUERY"),
+    executorVersion: z5.literal("1.0.0"),
+    apiVersion: z5.literal("2026-07"),
     schemaHash: HashSchema,
-    document: z4.string().min(1).refine((v) => new TextEncoder().encode(v).length <= 16384),
-    operationName: z4.string().refine(safeName),
+    document: z5.string().min(1).refine((v) => new TextEncoder().encode(v).length <= 16384),
+    operationName: z5.string().refine(safeName),
     variables: MappingsSchema,
-    resultPath: z4.string().refine(safePath)
+    resultPath: z5.string().refine(safePath)
   }),
-  z4.strictObject({
-    kind: z4.literal("POLICY_OPERATION"),
-    operation: z4.enum(POLICY_OPERATIONS),
-    operationVersion: z4.literal("1.0.0"),
+  z5.strictObject({
+    kind: z5.literal("POLICY_OPERATION"),
+    operation: z5.enum(POLICY_OPERATIONS),
+    operationVersion: z5.literal("1.0.0"),
     arguments: MappingsSchema
   }),
   ExternalHttpExecutionSchema
@@ -499,17 +600,17 @@ function tokensValid(text, root) {
   );
   return !residue.includes("{{") && !residue.includes("}}");
 }
-var fixed = z4.string().max(4096).refine((v) => !/[<>]|\{\{|\}\}/.test(v));
-var ResponseTemplateSchema = z4.discriminatedUnion("kind", [
-  z4.strictObject({
-    kind: z4.literal("text"),
-    text: z4.string().max(4096).refine((v) => tokensValid(v, "result")),
+var fixed = z5.string().max(4096).refine((v) => !/[<>]|\{\{|\}\}/.test(v));
+var ResponseTemplateSchema = z5.discriminatedUnion("kind", [
+  z5.strictObject({
+    kind: z5.literal("text"),
+    text: z5.string().max(4096).refine((v) => tokensValid(v, "result")),
     unavailable: fixed
   }),
-  z4.strictObject({
-    kind: z4.literal("items"),
-    itemsPath: z4.string().refine(safePath),
-    item: z4.string().max(4096).refine((v) => tokensValid(v, "item")),
+  z5.strictObject({
+    kind: z5.literal("items"),
+    itemsPath: z5.string().refine(safePath),
+    item: z5.string().max(4096).refine((v) => tokensValid(v, "item")),
     empty: fixed,
     unavailable: fixed
   })
@@ -517,11 +618,11 @@ var ResponseTemplateSchema = z4.discriminatedUnion("kind", [
 var identity = {
   name: ToolNameSchema,
   definitionVersion: SemverSchema,
-  description: z4.string().min(1).max(4096)
+  description: z5.string().min(1).max(4096)
 };
 var forbiddenInput = /^(shopid|customerid|checkoutrecoveryid|conversationid|grantid|releaseid|token|accesstoken|domain|headers|url|graphql|document|authorization)$/i;
 var forbiddenExternalInput = /^(authorization|cookie|set-cookie|host|x-api-key|api_key|apikey|access_token|token|secret|password)$/i;
-var CommerceToolDefinitionSchema = z4.strictObject({
+var CommerceToolDefinitionSchema = z5.strictObject({
   ...identity,
   inputSchema: InputSchemaSchema,
   execution: CommerceExecutionSchema,
@@ -557,7 +658,7 @@ var CommerceToolDefinitionSchema = z4.strictObject({
 var draftObject = boundedJson(65536).refine(
   (v) => !!v && typeof v === "object" && !Array.isArray(v)
 );
-var CommerceToolDraftDefinitionSchema = z4.strictObject({
+var CommerceToolDraftDefinitionSchema = z5.strictObject({
   ...identity,
   inputSchema: draftObject,
   execution: draftObject,
@@ -650,12 +751,12 @@ function validateDefinitionVersion(proposed, highestPublished) {
   SemverSchema.parse(highestPublished);
   return gt(proposed, highestPublished);
 }
-var CommerceToolIdentitySchema = z4.strictObject({
+var CommerceToolIdentitySchema = z5.strictObject({
   id: IdSchema,
   name: ToolNameSchema,
-  enabled: z4.boolean()
+  enabled: z5.boolean()
 });
-var CommerceToolRevisionIdentitySchema = z4.strictObject({
+var CommerceToolRevisionIdentitySchema = z5.strictObject({
   toolId: IdSchema,
   toolRevisionId: IdSchema,
   definitionVersion: SemverSchema,
@@ -707,10 +808,10 @@ function isTrustedCommerceBuiltInGrant(value) {
 }
 
 // src/commerce/response.ts
-import { z as z5 } from "zod";
-var CommerceResponseContractSchema = z5.strictObject({
-  version: z5.literal("response.v1"),
-  instructions: z5.string().min(1).max(8e3),
+import { z as z6 } from "zod";
+var CommerceResponseContractSchema = z6.strictObject({
+  version: z6.literal("response.v1"),
+  instructions: z6.string().min(1).max(8e3),
   detailsSchema: DetailsSchemaSchema
 }).refine((v) => jsonBytes(v) <= 32768);
 var EMPTY_RESPONSE_CONTRACT = {
@@ -723,31 +824,31 @@ var EMPTY_RESPONSE_CONTRACT = {
     additionalProperties: false
   }
 };
-var ReferralReasonSchema = z5.enum([
+var ReferralReasonSchema = z6.enum([
   "INSUFFICIENT_TOOLS",
   "UNVERIFIABLE_FACTS",
   "TOOL_UNAVAILABLE",
   "TOOL_REVOKED"
 ]);
-var DetectedLanguageTagSchema = z5.string().min(1).max(128).transform((value, ctx) => {
+var DetectedLanguageTagSchema = z6.string().min(1).max(128).transform((value, ctx) => {
   const canonical = canonicaliseLanguageTag(value);
   if (!canonical) {
     ctx.addIssue({
       code: "custom",
       message: "Invalid detected language tag"
     });
-    return z5.NEVER;
+    return z6.NEVER;
   }
   return canonical;
 });
-var CommerceFinalResponseSchema = z5.strictObject({
-  answerKind: z5.enum(["ANSWER", "REFER_TO_STORE"]),
-  replyText: z5.string().min(1).max(4096),
+var CommerceFinalResponseSchema = z6.strictObject({
+  answerKind: z6.enum(["ANSWER", "REFER_TO_STORE"]),
+  replyText: z6.string().min(1).max(4096),
   referralReason: ReferralReasonSchema.nullable(),
   detectedLanguageTag: DetectedLanguageTagSchema.nullable(),
-  detectedLanguageConfidence: z5.number().min(0).max(1).nullable(),
-  evidenceIds: z5.array(IdSchema).max(3).refine((v) => new Set(v).size === v.length),
-  details: z5.record(z5.string(), z5.unknown()).refine((v) => {
+  detectedLanguageConfidence: z6.number().min(0).max(1).nullable(),
+  evidenceIds: z6.array(IdSchema).max(3).refine((v) => new Set(v).size === v.length),
+  details: z6.record(z6.string(), z6.unknown()).refine((v) => {
     try {
       return jsonBytes(v) <= 16384;
     } catch {
@@ -883,22 +984,22 @@ function finalResponseToolSchema(definition) {
 }
 
 // src/commerce/schemas.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 import { validRange } from "semver";
-var CommerceTurnIdentitySchema = z6.strictObject({
+var CommerceTurnIdentitySchema = z7.strictObject({
   contractVersion: ContractVersionSchema,
   shopId: IdSchema,
   checkoutRecoveryId: IdSchema,
   conversationId: IdSchema,
-  inboundVersion: z6.number().int().positive()
+  inboundVersion: z7.number().int().positive()
 });
-var CommerceConversationGrantSchema = z6.strictObject({
+var CommerceConversationGrantSchema = z7.strictObject({
   id: IdSchema,
   shopId: IdSchema,
   conversationId: IdSchema,
-  initialInboundVersion: z6.number().int().positive(),
+  initialInboundVersion: z7.number().int().positive(),
   releaseId: IdSchema,
-  selectedCapabilityKeys: z6.array(IdSchema).max(32).refine(distinct),
+  selectedCapabilityKeys: z7.array(IdSchema).max(32).refine(distinct),
   purposeProfile: CommercePurposeProfileSchema.optional(),
   grantedTools: GrantedToolsSchema,
   runnerVersion: SemverSchema,
@@ -914,27 +1015,27 @@ var CommerceConversationGrantSchema = z6.strictObject({
   ))
     c.addIssue({ code: "custom", message: "Unselected grant provenance" });
 });
-var CommerceManifestSchema = z6.strictObject({
+var CommerceManifestSchema = z7.strictObject({
   contractVersion: ContractVersionSchema,
   releaseId: IdSchema,
-  runnerCompatibility: z6.string().min(1).max(128).refine((v) => !!validRange(v)),
-  capabilities: z6.array(
-    z6.strictObject({
+  runnerCompatibility: z7.string().min(1).max(128).refine((v) => !!validRange(v)),
+  capabilities: z7.array(
+    z7.strictObject({
       capabilityId: IdSchema,
       key: IdSchema,
       featureId: IdSchema,
-      position: z6.number().int().nonnegative(),
+      position: z7.number().int().nonnegative(),
       toolDescriptor: PublishedToolDescriptorSchema
     })
   ).max(32),
-  featureBehaviours: z6.array(
-    z6.strictObject({
+  featureBehaviours: z7.array(
+    z7.strictObject({
       featureId: IdSchema,
-      behaviourPrompt: z6.string().max(32e3)
+      behaviourPrompt: z7.string().max(32e3)
     })
   ).max(32),
-  selectedCapabilityKeys: z6.array(IdSchema).max(32).refine(distinct),
-  builtInTools: z6.array(CommerceBuiltInToolDescriptorSchema).max(2).default([]),
+  selectedCapabilityKeys: z7.array(IdSchema).max(32).refine(distinct),
+  builtInTools: z7.array(CommerceBuiltInToolDescriptorSchema).max(2).default([]),
   purposeProfile: CommercePurposeProfileSchema.optional(),
   grantedTools: GrantedToolsSchema,
   responseContract: CommerceResponseContractSchema,
@@ -989,32 +1090,32 @@ var CommerceManifestSchema = z6.strictObject({
       message: "Grant must equal selected capability set"
     });
 });
-var CommerceReleaseIdentitySchema = z6.strictObject({
+var CommerceReleaseIdentitySchema = z7.strictObject({
   contractVersion: ContractVersionSchema,
   releaseId: IdSchema,
-  runnerCompatibility: z6.string().min(1).max(128).refine((v) => !!validRange(v))
+  runnerCompatibility: z7.string().min(1).max(128).refine((v) => !!validRange(v))
 });
 var CommerceResolveAssertionSchema = CommerceTurnIdentitySchema.extend(
-  { purpose: z6.literal("resolve") }
+  { purpose: z7.literal("resolve") }
 );
 var CommerceExecuteAssertionSchema = CommerceTurnIdentitySchema.extend(
-  { purpose: z6.literal("execute"), grantId: IdSchema, releaseId: IdSchema }
+  { purpose: z7.literal("execute"), grantId: IdSchema, releaseId: IdSchema }
 );
-var CommerceAssertionSchema = z6.discriminatedUnion("purpose", [
+var CommerceAssertionSchema = z7.discriminatedUnion("purpose", [
   CommerceResolveAssertionSchema,
   CommerceExecuteAssertionSchema
 ]);
-var qty = z6.number().int().min(1).max(999);
-var CommerceProposalSchema = z6.strictObject({
-  operations: z6.array(
-    z6.discriminatedUnion("kind", [
-      z6.strictObject({
-        kind: z6.literal("ADD"),
+var qty = z7.number().int().min(1).max(999);
+var CommerceProposalSchema = z7.strictObject({
+  operations: z7.array(
+    z7.discriminatedUnion("kind", [
+      z7.strictObject({
+        kind: z7.literal("ADD"),
         variantId: IdSchema,
         quantity: qty
       }),
-      z6.strictObject({
-        kind: z6.literal("REPLACE"),
+      z7.strictObject({
+        kind: z7.literal("REPLACE"),
         lineId: IdSchema,
         variantId: IdSchema,
         quantity: qty
@@ -1026,13 +1127,13 @@ var CommerceProposalSchema = z6.strictObject({
     v.operations.flatMap((o) => o.kind === "REPLACE" ? [o.lineId] : [])
   )
 );
-var CommerceBasketSchema = z6.strictObject({
+var CommerceBasketSchema = z7.strictObject({
   basketId: IdSchema,
-  source: z6.enum(["RECOVERY_SNAPSHOT", "PROPOSED"]),
+  source: z7.enum(["RECOVERY_SNAPSHOT", "PROPOSED"]),
   observedAt: DateSchema,
   currency: CurrencySchema.nullable(),
-  lines: z6.array(
-    z6.strictObject({
+  lines: z7.array(
+    z7.strictObject({
       lineId: IdSchema,
       productId: IdSchema.nullable(),
       variantId: IdSchema.nullable(),
@@ -1041,14 +1142,14 @@ var CommerceBasketSchema = z6.strictObject({
     })
   ).max(100),
   fingerprint: HashSchema,
-  unknownFields: z6.array(z6.string().min(1).max(256)).max(128)
+  unknownFields: z7.array(z7.string().min(1).max(256)).max(128)
 }).refine((v) => distinct(v.lines.map((line) => line.lineId)));
-var CommerceProductSaleEvidenceSchema = z6.strictObject({
+var CommerceProductSaleEvidenceSchema = z7.strictObject({
   regularPrice: MoneySchema.nullable(),
   salePrice: MoneySchema.nullable(),
   observedAt: DateSchema
 });
-var optionLabel = z6.string().transform((value) => value.replace(/[\r\n\t]+/g, " ").trim()).pipe(z6.string().min(1).max(128).refine((value) => !/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/.test(value)));
+var optionLabel = z7.string().transform((value) => value.replace(/[\r\n\t]+/g, " ").trim()).pipe(z7.string().min(1).max(128).refine((value) => !/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/.test(value)));
 function normalizeCommerceProductOptions(raw) {
   if (raw === void 0 || raw === null) return { status: "NOT_PROVIDED", items: [] };
   const source = raw;
@@ -1084,9 +1185,9 @@ function normalizeCommerceProductOptions(raw) {
   }
   return { status: partial ? "PARTIAL" : items.length ? "AVAILABLE" : "NOT_PROVIDED", items };
 }
-var CommerceProductOptionsSchema = z6.preprocess(normalizeCommerceProductOptions, z6.strictObject({
-  status: z6.enum(["AVAILABLE", "NOT_PROVIDED", "PARTIAL"]),
-  items: z6.array(z6.strictObject({ name: optionLabel, values: z6.array(optionLabel).max(64), usedForVariants: z6.boolean().nullable() })).max(16)
+var CommerceProductOptionsSchema = z7.preprocess(normalizeCommerceProductOptions, z7.strictObject({
+  status: z7.enum(["AVAILABLE", "NOT_PROVIDED", "PARTIAL"]),
+  items: z7.array(z7.strictObject({ name: optionLabel, values: z7.array(optionLabel).max(64), usedForVariants: z7.boolean().nullable() })).max(16)
 }));
 function normalizeCommerceProductSelectedOptions(raw) {
   if (!Array.isArray(raw)) return [];
@@ -1099,31 +1200,33 @@ function normalizeCommerceProductSelectedOptions(raw) {
   }
   return result;
 }
-var CommerceProductSelectedOptionsSchema = z6.preprocess(normalizeCommerceProductSelectedOptions, z6.array(z6.strictObject({ name: optionLabel, value: optionLabel })).max(16));
-var CommerceProductSchema = z6.strictObject({
+var CommerceProductSelectedOptionsSchema = z7.preprocess(normalizeCommerceProductSelectedOptions, z7.array(z7.strictObject({ name: optionLabel, value: optionLabel })).max(16));
+var CommerceProductSchema = z7.strictObject({
+  description: z7.preprocess(normalizeCommerceProductDescriptionField, CommerceProductDescriptionSchema).optional(),
+  attributes: z7.preprocess(normalizeCommerceProductAttributes, CommerceProductAttributesSchema).optional(),
   options: CommerceProductOptionsSchema.optional(),
   selectedOptions: CommerceProductSelectedOptionsSchema.optional(),
   productId: IdSchema,
   variantId: IdSchema.nullable(),
-  title: z6.string().min(1).max(512),
-  url: z6.url({ protocol: /^https$/ }).refine((v) => {
+  title: z7.string().min(1).max(512),
+  url: z7.url({ protocol: /^https$/ }).refine((v) => {
     const u = new URL(v);
     return !u.username && !u.password && !u.port;
   }).nullable(),
-  available: z6.boolean().nullable(),
+  available: z7.boolean().nullable(),
   unitPrice: MoneySchema.nullable(),
   currency: CurrencySchema.nullable(),
-  productType: z6.string().max(512).nullable(),
-  vendor: z6.string().max(512).nullable(),
-  categories: z6.array(z6.string()).optional(),
-  categoryIds: z6.array(IdSchema).max(128).optional(),
-  collectionIds: z6.array(IdSchema).max(128).optional(),
-  imageUrl: z6.string().nullable().optional(),
+  productType: z7.string().max(512).nullable(),
+  vendor: z7.string().max(512).nullable(),
+  categories: z7.array(z7.string()).optional(),
+  categoryIds: z7.array(IdSchema).max(128).optional(),
+  collectionIds: z7.array(IdSchema).max(128).optional(),
+  imageUrl: z7.string().nullable().optional(),
   saleEvidence: CommerceProductSaleEvidenceSchema.nullable().optional(),
   observedAt: DateSchema
 });
 var discountUtcPattern = /^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.[0-9]+)?Z(?![\s\S])/;
-var CommerceDiscountDateTimeSchema = z6.string().regex(discountUtcPattern).refine((value) => {
+var CommerceDiscountDateTimeSchema = z7.string().regex(discountUtcPattern).refine((value) => {
   const match = discountUtcPattern.exec(value);
   if (!match) return false;
   const [year, month, day, hour, minute, second] = match.slice(1).map(Number);
@@ -1132,36 +1235,36 @@ var CommerceDiscountDateTimeSchema = z6.string().regex(discountUtcPattern).refin
   const daysInMonth = [31, leapYear ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
   return day >= 1 && day <= daysInMonth[month - 1];
 }, "Expected a valid UTC discount timestamp with seconds");
-var CommerceOfferSchema = z6.strictObject({
+var CommerceOfferSchema = z7.strictObject({
   offerId: IdSchema,
-  title: z6.string().min(1).max(512),
-  method: z6.enum(["AUTOMATIC", "CODE"]),
-  code: z6.string().min(1).max(128).nullable(),
+  title: z7.string().min(1).max(512),
+  method: z7.enum(["AUTOMATIC", "CODE"]),
+  code: z7.string().min(1).max(128).nullable(),
   startsAt: CommerceDiscountDateTimeSchema.nullable(),
   endsAt: CommerceDiscountDateTimeSchema.nullable(),
-  support: z6.enum(["SUPPORTED", "UNSUPPORTED", "UNKNOWN"]),
-  reasonCodes: z6.array(z6.string().min(1).max(64)).max(16)
+  support: z7.enum(["SUPPORTED", "UNSUPPORTED", "UNKNOWN"]),
+  reasonCodes: z7.array(z7.string().min(1).max(64)).max(16)
 }).refine(
   (v) => (v.startsAt === null || v.endsAt === null || Date.parse(v.startsAt) < Date.parse(v.endsAt)) && (v.method !== "AUTOMATIC" || v.code === null)
 );
-var CommerceDiscountCombinationFactsSchema = z6.strictObject({
-  discountClasses: z6.array(z6.enum(["ORDER", "PRODUCT", "SHIPPING"])).max(3).nullable(),
-  shopifyPlus: z6.boolean().nullable(),
-  combinesWith: z6.strictObject({
-    orderDiscounts: z6.boolean().nullable(),
-    productDiscounts: z6.boolean().nullable(),
-    shippingDiscounts: z6.boolean().nullable()
+var CommerceDiscountCombinationFactsSchema = z7.strictObject({
+  discountClasses: z7.array(z7.enum(["ORDER", "PRODUCT", "SHIPPING"])).max(3).nullable(),
+  shopifyPlus: z7.boolean().nullable(),
+  combinesWith: z7.strictObject({
+    orderDiscounts: z7.boolean().nullable(),
+    productDiscounts: z7.boolean().nullable(),
+    shippingDiscounts: z7.boolean().nullable()
   }).nullable(),
-  discountTags: z6.array(z6.string().min(1).max(128)).max(64).nullable(),
-  allowedSameLineProductTags: z6.array(z6.string().min(1).max(128)).max(64).nullable()
+  discountTags: z7.array(z7.string().min(1).max(128)).max(64).nullable(),
+  allowedSameLineProductTags: z7.array(z7.string().min(1).max(128)).max(64).nullable()
 });
-var CommerceDiscountConditionFactsSchema = z6.strictObject({
-  provider: z6.enum(["SHOPIFY", "WOOCOMMERCE"]),
-  completeness: z6.enum(["COMPLETE", "PARTIAL", "UNKNOWN"]),
+var CommerceDiscountConditionFactsSchema = z7.strictObject({
+  provider: z7.enum(["SHOPIFY", "WOOCOMMERCE"]),
+  completeness: z7.enum(["COMPLETE", "PARTIAL", "UNKNOWN"]),
   observedAt: CommerceDiscountDateTimeSchema,
-  providerStatus: z6.string().max(64),
+  providerStatus: z7.string().max(64),
   unavailableAt: CommerceDiscountDateTimeSchema.nullable(),
-  discountKind: z6.enum([
+  discountKind: z7.enum([
     "PERCENTAGE",
     "FIXED_AMOUNT",
     "FREE_SHIPPING",
@@ -1171,8 +1274,8 @@ var CommerceDiscountConditionFactsSchema = z6.strictObject({
   ]),
   discountValue: MoneySchema.nullable(),
   discountCurrency: CurrencySchema.nullable(),
-  targeting: z6.strictObject({
-    kind: z6.enum([
+  targeting: z7.strictObject({
+    kind: z7.enum([
       "ALL",
       "PRODUCTS",
       "VARIANTS",
@@ -1181,38 +1284,38 @@ var CommerceDiscountConditionFactsSchema = z6.strictObject({
       "MIXED",
       "UNKNOWN"
     ]),
-    includedProductIds: z6.array(IdSchema).max(128),
-    includedVariantIds: z6.array(IdSchema).max(128),
-    includedCategoryIds: z6.array(IdSchema).max(128),
-    includedCollectionIds: z6.array(IdSchema).max(128),
-    excludedProductIds: z6.array(IdSchema).max(128),
-    excludedVariantIds: z6.array(IdSchema).max(128),
-    excludedCategoryIds: z6.array(IdSchema).max(128),
-    excludedCollectionIds: z6.array(IdSchema).max(128)
+    includedProductIds: z7.array(IdSchema).max(128),
+    includedVariantIds: z7.array(IdSchema).max(128),
+    includedCategoryIds: z7.array(IdSchema).max(128),
+    includedCollectionIds: z7.array(IdSchema).max(128),
+    excludedProductIds: z7.array(IdSchema).max(128),
+    excludedVariantIds: z7.array(IdSchema).max(128),
+    excludedCategoryIds: z7.array(IdSchema).max(128),
+    excludedCollectionIds: z7.array(IdSchema).max(128)
   }),
   minimumSubtotal: MoneySchema.nullable(),
   maximumSubtotal: MoneySchema.nullable(),
   subtotalRequirementCurrency: CurrencySchema.nullable(),
-  minimumQuantity: z6.number().int().nonnegative().nullable(),
-  usageLimit: z6.number().int().nonnegative().nullable(),
-  usageCount: z6.number().int().nonnegative().nullable(),
-  perCustomerLimit: z6.number().int().nonnegative().nullable(),
-  customerScope: z6.enum(["ALL", "RESTRICTED", "UNKNOWN"]),
-  excludesSaleItems: z6.boolean().nullable(),
-  individualUse: z6.boolean().nullable(),
+  minimumQuantity: z7.number().int().nonnegative().nullable(),
+  usageLimit: z7.number().int().nonnegative().nullable(),
+  usageCount: z7.number().int().nonnegative().nullable(),
+  perCustomerLimit: z7.number().int().nonnegative().nullable(),
+  customerScope: z7.enum(["ALL", "RESTRICTED", "UNKNOWN"]),
+  excludesSaleItems: z7.boolean().nullable(),
+  individualUse: z7.boolean().nullable(),
   combination: CommerceDiscountCombinationFactsSchema,
-  unrepresentedConditions: z6.array(z6.string().min(1).max(128)).max(24)
+  unrepresentedConditions: z7.array(z7.string().min(1).max(128)).max(24)
 });
-var CommerceDiscountDetailsSchema = z6.strictObject({
+var CommerceDiscountDetailsSchema = z7.strictObject({
   offer: CommerceOfferSchema,
   facts: CommerceDiscountConditionFactsSchema,
-  providerDiscountId: z6.string().min(1).max(191).nullable()
+  providerDiscountId: z7.string().min(1).max(191).nullable()
 });
-var condition = z6.strictObject({
-  code: z6.string().min(1).max(64),
-  description: z6.string().max(256)
+var condition = z7.strictObject({
+  code: z7.string().min(1).max(64),
+  description: z7.string().max(256)
 });
-var CommerceEvidenceSchema = z6.strictObject({
+var CommerceEvidenceSchema = z7.strictObject({
   evidenceId: HashSchema,
   turn: CommerceTurnIdentitySchema,
   grantId: IdSchema,
@@ -1223,7 +1326,7 @@ var CommerceEvidenceSchema = z6.strictObject({
   ruleFingerprint: HashSchema,
   evaluatedAt: DateSchema,
   expiresAt: DateSchema,
-  outcome: z6.enum([
+  outcome: z7.enum([
     "QUALIFIES_FOR_KNOWN_RULES",
     "DOES_NOT_QUALIFY",
     "UNKNOWN",
@@ -1232,8 +1335,8 @@ var CommerceEvidenceSchema = z6.strictObject({
   currency: CurrencySchema.nullable(),
   savings: MoneySchema.nullable(),
   resultingTotal: MoneySchema.nullable(),
-  evaluatedConditions: z6.array(condition).max(32),
-  unresolvedConditions: z6.array(condition).max(32)
+  evaluatedConditions: z7.array(condition).max(32),
+  unresolvedConditions: z7.array(condition).max(32)
 }).superRefine((v, c) => {
   if (Date.parse(v.expiresAt) - Date.parse(v.evaluatedAt) > 6e4)
     c.addIssue({
@@ -1243,16 +1346,16 @@ var CommerceEvidenceSchema = z6.strictObject({
   if (v.outcome === "QUALIFIES_FOR_KNOWN_RULES" && (v.unresolvedConditions.length || Date.parse(v.expiresAt) <= Date.parse(v.evaluatedAt) || v.currency === null || v.savings === null || v.resultingTotal === null))
     c.addIssue({ code: "custom", message: "Unsupported qualifying claim" });
 });
-var CommerceAlternativeSchema = z6.strictObject({
+var CommerceAlternativeSchema = z7.strictObject({
   product: CommerceProductSchema,
   proposal: CommerceProposalSchema,
   extraSpend: MoneySchema.nullable(),
   resultingTotal: MoneySchema.nullable(),
   currency: CurrencySchema.nullable(),
   evidence: CommerceEvidenceSchema.nullable(),
-  similarityReasons: z6.array(z6.string().max(256)).max(3)
+  similarityReasons: z7.array(z7.string().max(256)).max(3)
 }).refine((v) => v.product.available === true);
-var CommerceErrorCodeSchema = z6.enum([
+var CommerceErrorCodeSchema = z7.enum([
   "INVALID_INPUT",
   "DENIED",
   "STALE_TURN",
@@ -1263,184 +1366,189 @@ var CommerceErrorCodeSchema = z6.enum([
   "INCOMPATIBLE_VERSION"
 ]);
 function commerceToolResultSchema(data) {
-  return z6.union([
-    z6.strictObject({
+  return z7.union([
+    z7.strictObject({
       contractVersion: ContractVersionSchema,
-      status: z6.literal("OK"),
+      status: z7.literal("OK"),
       data,
-      renderedText: z6.string().max(4096)
+      renderedText: z7.string().max(4096)
     }),
-    z6.strictObject({
+    z7.strictObject({
       contractVersion: ContractVersionSchema,
-      status: z6.literal("ERROR"),
+      status: z7.literal("ERROR"),
       code: CommerceErrorCodeSchema,
-      retryable: z6.boolean(),
-      renderedText: z6.string().max(4096).optional()
+      retryable: z7.boolean(),
+      renderedText: z7.string().max(4096).optional()
     })
   ]);
 }
 var CommerceToolResultSchema = commerceToolResultSchema(
   boundedJson(262144)
 );
-var wireId = z6.string().min(1).max(128);
-var taxonomySource = z6.enum(["SHOPIFY_STANDARD_PRODUCT_TAXONOMY"]).meta({ maxLength: 33 });
-var CommerceCategoryCandidateSchema = z6.strictObject({
+var wireId = z7.string().min(1).max(128);
+var taxonomySource = z7.enum(["SHOPIFY_STANDARD_PRODUCT_TAXONOMY"]).meta({ maxLength: 33 });
+var CommerceCategoryCandidateSchema = z7.strictObject({
   categoryId: wireId,
-  name: z6.string().min(1).max(512),
-  fullName: z6.string().min(1).max(4096),
+  name: z7.string().min(1).max(512),
+  fullName: z7.string().min(1).max(4096),
   parentId: wireId.nullable(),
-  level: z6.number().int().min(0).max(32),
-  ancestorIds: z6.array(wireId).max(32),
-  distance: z6.number().min(0).max(2)
+  level: z7.number().int().min(0).max(32),
+  ancestorIds: z7.array(wireId).max(32),
+  distance: z7.number().min(0).max(2)
 });
-var CommerceCategoryResolutionSchema = z6.union([
-  z6.strictObject({
-    outcome: z6.enum(["CANDIDATES", "NO_CANDIDATES"]).meta({ maxLength: 13 }),
+var CommerceCategoryResolutionSchema = z7.union([
+  z7.strictObject({
+    outcome: z7.enum(["CANDIDATES", "NO_CANDIDATES"]).meta({ maxLength: 13 }),
     generationId: wireId,
     source: taxonomySource,
-    taxonomyVersion: z6.string().min(1).max(64),
-    languageTag: z6.string().min(1).max(35),
-    candidates: z6.array(CommerceCategoryCandidateSchema).max(10)
+    taxonomyVersion: z7.string().min(1).max(64),
+    languageTag: z7.string().min(1).max(35),
+    candidates: z7.array(CommerceCategoryCandidateSchema).max(10)
   }),
-  z6.strictObject({
-    outcome: z6.enum(["UNAVAILABLE"]).meta({ maxLength: 11 }),
-    reasonCode: z6.enum(["NOT_READY", "TEMPORARY_UNAVAILABLE"]).meta({ maxLength: 21 })
+  z7.strictObject({
+    outcome: z7.enum(["UNAVAILABLE"]).meta({ maxLength: 11 }),
+    reasonCode: z7.enum(["NOT_READY", "TEMPORARY_UNAVAILABLE"]).meta({ maxLength: 21 })
   })
 ]);
-var CommerceOptionalLookupUnavailableSchema = z6.strictObject({
-  outcome: z6.enum(["UNAVAILABLE"]).meta({ maxLength: 11 }),
-  reasonCode: z6.enum(["TEMPORARY_UNAVAILABLE"]).meta({ maxLength: 21 })
+var CommerceOptionalLookupUnavailableSchema = z7.strictObject({
+  outcome: z7.enum(["UNAVAILABLE"]).meta({ maxLength: 11 }),
+  reasonCode: z7.enum(["TEMPORARY_UNAVAILABLE"]).meta({ maxLength: 21 })
 });
-var CommerceProductRecommendationSelectionSchema = z6.strictObject({
-  productRecommendationVersion: z6.enum(["1"]).meta({ maxLength: 1 }).optional(),
-  productRecommendations: z6.array(z6.strictObject({
-    scope: z6.enum(["PRODUCT_ONLY", "ADD_TO_BASKET", "REPLACE_BASKET_LINE"]).meta({ maxLength: 19 }),
+var CommerceProductRecommendationSelectionSchema = z7.strictObject({
+  productRecommendationVersion: z7.enum(["1"]).meta({ maxLength: 1 }).optional(),
+  productRecommendations: z7.array(z7.strictObject({
+    scope: z7.enum(["PRODUCT_ONLY", "ADD_TO_BASKET", "REPLACE_BASKET_LINE"]).meta({ maxLength: 19 }),
     basketLineId: wireId.nullable(),
     productId: wireId,
     variantId: wireId.nullable(),
-    quantity: z6.number().int().min(1).max(99),
-    promotionKind: z6.enum(["NONE", "NATIVE_SALE", "DISCOUNT"]).meta({ maxLength: 11 }),
-    offerIds: z6.array(wireId).max(3)
+    quantity: z7.number().int().min(1).max(99),
+    promotionKind: z7.enum(["NONE", "NATIVE_SALE", "DISCOUNT"]).meta({ maxLength: 11 }),
+    offerIds: z7.array(wireId).max(3)
   })).min(1).max(3).optional()
 });
-var CommerceResponseDispositionSchema = z6.enum([
+var CommerceResponseDispositionSchema = z7.enum([
   "STANDARD",
   "OUT_OF_SCOPE_REDIRECT",
   "SHIPPING_INFORMATION_UNVERIFIED",
-  "PRODUCT_OPTIONS"
+  "PRODUCT_OPTIONS",
+  "PRODUCT_DETAILS"
 ]).meta({ maxLength: 31 });
-var CommerceAnswerPresentationSelectionSchema = z6.strictObject({
-  productOptionSelections: z6.array(z6.strictObject({ productId: wireId, variantId: wireId.nullable() })).max(3).optional(),
+var CommerceAnswerPresentationSelectionSchema = z7.strictObject({
+  productOptionSelections: z7.array(z7.strictObject({ productId: wireId, variantId: wireId.nullable() })).max(3).optional(),
+  productDetailSelections: z7.array(z7.strictObject({ productId: wireId, variantId: wireId.nullable() })).max(3).refine(
+    (selections) => new Set(selections.map((selection) => JSON.stringify([selection.productId, selection.variantId]))).size === selections.length,
+    "Duplicate product detail selection"
+  ).optional(),
   responseDisposition: CommerceResponseDispositionSchema.optional(),
-  shippingInformationSelection: z6.strictObject({
+  shippingInformationSelection: z7.strictObject({
     productId: wireId.nullable(),
     variantId: wireId.nullable()
   }).optional()
 });
-var CommerceShippingInformationInputSchema = z6.strictObject({
+var CommerceShippingInformationInputSchema = z7.strictObject({
   productId: wireId.nullable().default(null),
   variantId: wireId.nullable().default(null)
 });
-var CommerceShippingInformationSchema = z6.strictObject({
-  provider: z6.enum(["SHOPIFY", "WOOCOMMERCE"]).meta({ maxLength: 11 }),
+var CommerceShippingInformationSchema = z7.strictObject({
+  provider: z7.enum(["SHOPIFY", "WOOCOMMERCE"]).meta({ maxLength: 11 }),
   observedAt: DateSchema,
-  product: z6.strictObject({
-    status: z6.enum(["NOT_REQUESTED", "VARIANT_REQUIRED", "AVAILABLE"]).meta({ maxLength: 16 }),
+  product: z7.strictObject({
+    status: z7.enum(["NOT_REQUESTED", "VARIANT_REQUIRED", "AVAILABLE"]).meta({ maxLength: 16 }),
     productId: wireId.nullable(),
     variantId: wireId.nullable(),
-    requiresShipping: z6.boolean().nullable(),
-    virtual: z6.boolean().nullable(),
-    weight: z6.strictObject({
-      value: z6.number().min(0),
-      unit: z6.enum(["GRAMS", "KILOGRAMS", "OUNCES", "POUNDS"]).meta({ maxLength: 9 }).nullable()
+    requiresShipping: z7.boolean().nullable(),
+    virtual: z7.boolean().nullable(),
+    weight: z7.strictObject({
+      value: z7.number().min(0),
+      unit: z7.enum(["GRAMS", "KILOGRAMS", "OUNCES", "POUNDS"]).meta({ maxLength: 9 }).nullable()
     }).nullable(),
-    dimensions: z6.strictObject({
-      length: z6.number().min(0).nullable(),
-      width: z6.number().min(0).nullable(),
-      height: z6.number().min(0).nullable(),
-      unit: z6.string().min(1).max(16).nullable()
+    dimensions: z7.strictObject({
+      length: z7.number().min(0).nullable(),
+      width: z7.number().min(0).nullable(),
+      height: z7.number().min(0).nullable(),
+      unit: z7.string().min(1).max(16).nullable()
     }).nullable(),
     shippingClassId: wireId.nullable(),
-    shippingClassSlug: z6.string().min(1).max(512).nullable()
+    shippingClassSlug: z7.string().min(1).max(512).nullable()
   }),
-  policy: z6.strictObject({
-    status: z6.enum(["AVAILABLE", "NOT_CONFIGURED", "SCOPE_NOT_GRANTED", "UNSUPPORTED"]).meta({ maxLength: 17 }),
-    trust: z6.enum(["UNTRUSTED_REFERENCE"]).meta({ maxLength: 19 }),
-    title: z6.string().min(1).max(512).nullable(),
-    bodyStatus: z6.enum(["AVAILABLE", "EMPTY", "TOO_LARGE", "NOT_AVAILABLE"]).meta({ maxLength: 13 }),
-    bodyHtml: z6.string().min(1).max(8e3).nullable(),
-    url: z6.url({ protocol: /^https$/ }).min(1).max(2048).nullable(),
+  policy: z7.strictObject({
+    status: z7.enum(["AVAILABLE", "NOT_CONFIGURED", "SCOPE_NOT_GRANTED", "UNSUPPORTED"]).meta({ maxLength: 17 }),
+    trust: z7.enum(["UNTRUSTED_REFERENCE"]).meta({ maxLength: 19 }),
+    title: z7.string().min(1).max(512).nullable(),
+    bodyStatus: z7.enum(["AVAILABLE", "EMPTY", "TOO_LARGE", "NOT_AVAILABLE"]).meta({ maxLength: 13 }),
+    bodyHtml: z7.string().min(1).max(8e3).nullable(),
+    url: z7.url({ protocol: /^https$/ }).min(1).max(2048).nullable(),
     updatedAt: DateSchema.nullable()
   })
 });
-var limit = z6.number().int().min(1).max(3).default(3);
+var limit = z7.number().int().min(1).max(3).default(3);
 var CommerceToolInputs = {
-  commerce_resolve_product_categories: z6.strictObject({
-    query: z6.string().min(1).max(200),
-    limit: z6.number().int().min(1).max(10).default(5)
+  commerce_resolve_product_categories: z7.strictObject({
+    query: z7.string().min(1).max(200),
+    limit: z7.number().int().min(1).max(10).default(5)
   }),
   commerce_get_shipping_information: CommerceShippingInformationInputSchema,
-  commerce_get_basket: z6.strictObject({}),
-  commerce_search_products: z6.strictObject({
-    query: z6.string().min(1).max(200).nullable().default(null),
-    category: z6.strictObject({
-      system: z6.enum(["SHOPIFY_STANDARD_PRODUCT_TAXONOMY", "WOOCOMMERCE_PRODUCT_CATEGORY"]).meta({ maxLength: 33 }),
+  commerce_get_basket: z7.strictObject({}),
+  commerce_search_products: z7.strictObject({
+    query: z7.string().min(1).max(200).nullable().default(null),
+    category: z7.strictObject({
+      system: z7.enum(["SHOPIFY_STANDARD_PRODUCT_TAXONOMY", "WOOCOMMERCE_PRODUCT_CATEGORY"]).meta({ maxLength: 33 }),
       id: wireId,
-      taxonomyVersion: z6.string().min(1).max(64).nullable()
+      taxonomyVersion: z7.string().min(1).max(64).nullable()
     }).optional(),
-    browse: z6.boolean().default(false),
+    browse: z7.boolean().default(false),
     maximumPrice: MoneySchema.optional(),
-    availableOnly: z6.boolean().default(true),
-    limit: z6.number().int().min(1).max(20).default(10),
-    cursor: z6.string().max(2048).nullable().default(null)
+    availableOnly: z7.boolean().default(true),
+    limit: z7.number().int().min(1).max(20).default(10),
+    cursor: z7.string().max(2048).nullable().default(null)
   }),
-  commerce_get_product: z6.strictObject({
+  commerce_get_product: z7.strictObject({
     productId: IdSchema,
     variantId: IdSchema.nullable()
   }),
-  commerce_get_discount_options: z6.strictObject({
-    limit: z6.number().int().min(1).max(50).default(20),
-    cursor: z6.string().max(2048).nullable().default(null)
+  commerce_get_discount_options: z7.strictObject({
+    limit: z7.number().int().min(1).max(50).default(20),
+    cursor: z7.string().max(2048).nullable().default(null)
   }),
-  commerce_get_discount_details: z6.strictObject({ offerId: IdSchema }),
-  commerce_evaluate_discount: z6.strictObject({
+  commerce_get_discount_details: z7.strictObject({ offerId: IdSchema }),
+  commerce_evaluate_discount: z7.strictObject({
     offerId: IdSchema,
     proposal: CommerceProposalSchema.nullable()
   }),
-  commerce_find_qualifying_products: z6.strictObject({
+  commerce_find_qualifying_products: z7.strictObject({
     offerId: IdSchema,
-    query: z6.string().min(1).max(200).nullable(),
+    query: z7.string().min(1).max(200).nullable(),
     limit
   }),
-  commerce_find_similar_products: z6.strictObject({
+  commerce_find_similar_products: z7.strictObject({
     variantId: IdSchema,
     offerId: IdSchema.nullable(),
     limit
   })
 };
-var alternatives = z6.strictObject({
-  alternatives: z6.array(CommerceAlternativeSchema).max(3),
-  truncated: z6.boolean()
+var alternatives = z7.strictObject({
+  alternatives: z7.array(CommerceAlternativeSchema).max(3),
+  truncated: z7.boolean()
 });
 var CommerceToolOutputs = {
   commerce_resolve_product_categories: CommerceCategoryResolutionSchema,
   commerce_get_shipping_information: CommerceShippingInformationSchema,
   commerce_get_basket: CommerceBasketSchema,
-  commerce_search_products: z6.strictObject({
-    products: z6.array(CommerceProductSchema).max(20),
-    cursor: z6.string().max(2048).nullable(),
-    truncated: z6.boolean()
+  commerce_search_products: z7.strictObject({
+    products: z7.array(CommerceProductSchema).max(20),
+    cursor: z7.string().max(2048).nullable(),
+    truncated: z7.boolean()
   }),
-  commerce_get_product: z6.strictObject({
+  commerce_get_product: z7.strictObject({
     product: CommerceProductSchema.nullable()
   }),
-  commerce_get_discount_options: z6.union([CommerceOptionalLookupUnavailableSchema, z6.strictObject({
-    mode: z6.enum(["NONE", "FIXED", "AI_BEST_APPLICABLE"]),
-    offers: z6.array(CommerceOfferSchema).max(50),
-    truncated: z6.boolean(),
-    cursor: z6.string().max(2048).nullable().optional()
+  commerce_get_discount_options: z7.union([CommerceOptionalLookupUnavailableSchema, z7.strictObject({
+    mode: z7.enum(["NONE", "FIXED", "AI_BEST_APPLICABLE"]),
+    offers: z7.array(CommerceOfferSchema).max(50),
+    truncated: z7.boolean(),
+    cursor: z7.string().max(2048).nullable().optional()
   })]),
-  commerce_get_discount_details: z6.union([CommerceOptionalLookupUnavailableSchema, z6.strictObject({
+  commerce_get_discount_details: z7.union([CommerceOptionalLookupUnavailableSchema, z7.strictObject({
     details: CommerceDiscountDetailsSchema.nullable()
   })]),
   commerce_evaluate_discount: CommerceEvidenceSchema,
@@ -1456,6 +1564,11 @@ function productBelongsToDomain(product, verifiedDomain) {
 }
 
 export {
+  CommerceProductDescriptionSchema,
+  CommerceProductAttributesSchema,
+  normalizeCommerceProductDescription,
+  normalizeCommerceProductAttributes,
+  normalizeCommerceProductDescriptionField,
   MONEY_PATTERN,
   safeName,
   safePath,
@@ -1559,4 +1672,4 @@ export {
   CommerceToolOutputs,
   productBelongsToDomain
 };
-//# sourceMappingURL=chunk-S42O2OCG.js.map
+//# sourceMappingURL=chunk-SW2AFMT7.js.map