@modainteract/moda-interact-shared 5.3.0 → 5.5.0

package/dist/{chunk-6OBYUIQ3.js → chunk-BDGLKOCW.js}

@@ -155,40 +155,148 @@ function compileSubset(schema, mode) {
   });
 }
 
-// src/commerce/external.ts
+// src/commerce/purpose-output.ts
 import { z as z2 } 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})?$",
+  "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z))$",
+  "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$"
+];
+var MONEY = CANONICAL_PATTERNS.find((pattern) => pattern.includes("1,18"));
+var STRICT_DATETIME = CANONICAL_PATTERNS.find((pattern) => pattern.includes("2468"));
+var DATETIME = CANONICAL_PATTERNS.find((pattern) => pattern !== MONEY && pattern !== STRICT_DATETIME);
+var MINUTE_DATETIME = CANONICAL_PATTERNS[3];
+var scalarTypes = ["string", "number", "integer", "boolean", "object", "array"];
+var baseKeys = ["type", "description", "enum"];
+var typeKeys = {
+  object: ["properties", "required", "additionalProperties"],
+  array: ["items", "minItems", "maxItems"],
+  string: ["minLength", "maxLength", "pattern", "format"],
+  number: ["minimum", "maximum"],
+  integer: ["minimum", "maximum"],
+  boolean: []
+};
+function record(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value) && [Object.prototype, null].includes(Object.getPrototypeOf(value)));
+}
+function datetime(value, allowMinutes = false) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?Z$/.exec(value);
+  if (!match || match[0].length !== value.length) return false;
+  const [, y, m, d, h, minute, second] = match;
+  if (!allowMinutes && second === void 0) return false;
+  const year = Number(y), month = Number(m), day = Number(d);
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return month >= 1 && month <= 12 && day >= 1 && day <= days[month - 1] && Number(h) <= 23 && Number(minute) <= 59 && Number(second ?? 0) <= 59;
+}
+function validateCommercePurposeOutputSchema(value) {
+  let nodes = 0, properties = 0;
+  function walk(raw, depth, root = false) {
+    if (depth > 8 || ++nodes > 256 || !record(raw)) return false;
+    const s = raw;
+    if (s.description !== void 0 && (typeof s.description !== "string" || s.description.length > 1e3)) return false;
+    if (Object.hasOwn(s, "anyOf")) return Object.keys(s).every((key) => ["anyOf", "description"].includes(key)) && Array.isArray(s.anyOf) && s.anyOf.length >= 2 && s.anyOf.length <= 4 && s.anyOf.every((branch) => walk(branch, depth + 1, root));
+    const nullable = Array.isArray(s.type);
+    if (nullable && (s.type.length !== 2 || s.type[1] !== "null")) return false;
+    const type = nullable ? s.type[0] : s.type;
+    if (typeof type !== "string" || !scalarTypes.includes(type) || root && (type !== "object" || nullable)) return false;
+    if (Object.keys(s).some((key) => ![...baseKeys, ...typeKeys[type]].includes(key))) return false;
+    if (s.enum !== void 0 && (!Array.isArray(s.enum) || s.enum.length < 1 || s.enum.length > 32 || new Set(s.enum.map((v) => canonicalJson(v))).size !== s.enum.length || s.enum.some((v) => v === null ? !nullable : typeof v !== (type === "integer" ? "number" : type) || type === "integer" && !Number.isSafeInteger(v) || typeof v === "object"))) return false;
+    for (const [min, max] of [["minLength", "maxLength"], ["minItems", "maxItems"], ["minimum", "maximum"]]) {
+      if ([s[min], s[max]].some((v) => v !== void 0 && (typeof v !== "number" || !Number.isFinite(v) || min !== "minimum" && (!Number.isSafeInteger(v) || v < 0)))) return false;
+      if (s[min] !== void 0 && s[max] !== void 0 && s[min] > s[max]) return false;
+    }
+    if (type === "string") return (s.maxLength === void 0 || s.maxLength <= 4096) && (s.minLength ?? 0) <= (s.maxLength ?? 4096) && (s.pattern === void 0 || CANONICAL_PATTERNS.includes(s.pattern)) && (s.format === void 0 || s.format === "uri" || s.format === "date-time");
+    if (type === "array") return (s.maxItems === void 0 || s.maxItems <= 128) && (s.minItems ?? 0) <= (s.maxItems ?? 128) && walk(s.items, depth + 1);
+    if (type === "object") {
+      if (s.additionalProperties !== false || !record(s.properties)) return false;
+      const names = Object.keys(s.properties);
+      properties += names.length;
+      return properties <= 128 && names.every(safeName) && (s.required === void 0 || Array.isArray(s.required) && new Set(s.required).size === s.required.length && s.required.every((name) => typeof name === "string" && names.includes(name))) && Object.values(s.properties).every((child) => walk(child, depth + 1));
+    }
+    return true;
+  }
+  try {
+    return jsonBytes(value) <= 32768 && walk(value, 1, true);
+  } catch {
+    return false;
+  }
+}
+var CommercePurposeOutputSchemaSchema = z2.custom(validateCommercePurposeOutputSchema);
+function matches(schema, value) {
+  if (schema.anyOf) return schema.anyOf.some((branch) => matches(branch, value));
+  const nullable = Array.isArray(schema.type);
+  const type = nullable ? schema.type[0] : schema.type;
+  if (value === null) return nullable && (!schema.enum || schema.enum.includes(null));
+  if (schema.enum && !schema.enum.includes(value)) return false;
+  if (type === "string") {
+    if (typeof value !== "string" || value.length < (schema.minLength ?? 0) || value.length > (schema.maxLength ?? 4096)) return false;
+    if (schema.pattern === MONEY && (!/^[0-9]{1,18}(\.[0-9]{1,6})?$/.test(value) || /[\r\n]/.test(value))) return false;
+    if (schema.pattern === DATETIME && !datetime(value)) return false;
+    if ((schema.pattern === STRICT_DATETIME || schema.pattern === MINUTE_DATETIME || schema.format === "date-time") && !datetime(value, schema.pattern !== STRICT_DATETIME)) return false;
+    if (schema.format === "uri") {
+      try {
+        const url = new URL(value);
+        if (url.protocol !== "https:" || url.username || url.password || url.port) return false;
+      } catch {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (type === "boolean") return typeof value === "boolean";
+  if (type === "number" || type === "integer") return typeof value === "number" && Number.isFinite(value) && (type !== "integer" || Number.isSafeInteger(value)) && value >= (schema.minimum ?? -Infinity) && value <= (schema.maximum ?? Infinity);
+  if (type === "array") return Array.isArray(value) && value.length >= (schema.minItems ?? 0) && value.length <= (schema.maxItems ?? 128) && value.every((item) => matches(schema.items, item));
+  if (!record(value)) return false;
+  return Object.keys(value).every((key) => Object.hasOwn(schema.properties, key)) && (schema.required ?? []).every((key) => Object.hasOwn(value, key)) && Object.entries(value).every(([key, child]) => matches(schema.properties[key], child));
+}
+function compileCommercePurposeOutputSchema(raw) {
+  if (!validateCommercePurposeOutputSchema(raw)) throw new TypeError("Unsupported purpose output schema");
+  const snapshot = structuredClone(raw);
+  return z2.custom((value) => {
+    try {
+      return jsonBytes(value) <= 32768 && matches(snapshot, value);
+    } catch {
+      return false;
+    }
+  });
+}
+
+// src/commerce/external.ts
+import { z as z3 } from "zod";
 var utf8 = (value, maximum) => new TextEncoder().encode(value).length <= maximum;
-var scalar = z2.union([z2.string().refine((value) => utf8(value, 2048)), z2.number().finite(), z2.boolean()]);
+var scalar = z3.union([z3.string().refine((value) => utf8(value, 2048)), z3.number().finite(), z3.boolean()]);
 var ExternalQueryValueSchema = scalar;
-var scalarOrNull = z2.union([scalar, z2.null()]);
-var record = (item, max) => z2.record(z2.string().refine(safeName), item).refine((value) => Object.keys(value).length <= max);
-var ExternalQueryMappingSchema = z2.union([
-  z2.strictObject({ input: z2.string().refine(safeName), omitIfMissing: z2.literal(true).optional() }),
-  z2.strictObject({ literal: 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 ExternalQueryMappingsSchema = record(ExternalQueryMappingSchema, 32).superRefine((value, ctx) => {
+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 = z2.string().max(1024).refine(
+var ExternalPathSchema = z3.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 = z2.string().min(1).max(128).refine((value) => value === value.toLowerCase() && /^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(value));
+var mediaType = z3.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 = z2.strictObject({ mode: z2.enum(["JSON", "TEXT"]), mediaTypes: z2.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 = record(z2.strictObject({ path: z2.string().refine(safePath), omitIfMissing: z2.literal(true).optional() }), 32).refine((value) => Object.keys(value).length >= 1);
-var ResponseFilterSchema = z2.discriminatedUnion("op", [
-  z2.strictObject({ path: z2.string().refine(safePath), op: z2.enum(["EQ", "NE", "GT", "GTE", "LT", "LTE", "CONTAINS", "STARTS_WITH"]), value: scalarOrNull }),
-  z2.strictObject({ path: z2.string().refine(safePath), op: z2.literal("IN"), values: z2.array(scalarOrNull).min(1).max(20) })
+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 visualObject = z2.strictObject({ kind: z2.literal("OBJECT"), fields: FieldProjectionSchema });
-var visualList = z2.strictObject({ kind: z2.literal("LIST"), fields: FieldProjectionSchema, filters: z2.array(ResponseFilterSchema).max(8), sort: z2.union([z2.null(), z2.strictObject({ path: z2.string().refine(safePath), direction: z2.enum(["ASC", "DESC"]) })]), limit: z2.int().min(1).max(20) });
-var VisualResponseProcessingSchema = z2.union([visualObject, visualList]);
-var ResponseProcessingSchema = z2.union([VisualResponseProcessingSchema, z2.strictObject({ kind: z2.literal("JAVASCRIPT"), runtimeVersion: z2.literal("quickjs-sync.v1"), source: z2.string().min(1).refine((value) => utf8(value, 16384)) })]);
-var TransformResponseSchema = z2.strictObject({ status: z2.int().min(200).max(299), contentType: z2.string().min(1).max(128), bodyText: z2.string().refine((value) => utf8(value, 262144)), json: z2.union([z2.null(), z2.json()]) });
-var TransformSampleSchema = z2.strictObject({ status: z2.int().min(200).max(299), contentType: z2.string().min(1).max(128), bodyText: z2.string().refine((value) => utf8(value, 262144)) }).refine((value) => jsonBytes(value) <= 524288);
-var boundedValues = z2.custom((value) => {
+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) => {
   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;
@@ -196,24 +304,24 @@ var boundedValues = z2.custom((value) => {
     return false;
   }
 });
-var ExternalHttpResultDataSchema = z2.strictObject({ source: z2.literal("EXTERNAL_HTTP"), connectionRevisionId: IdSchema, observedAt: DateSchema, values: boundedValues });
-var ConnectionRevisionViewSchema = z2.strictObject({ id: IdSchema, connectionId: IdSchema, revisionNumber: z2.int().positive(), origin: z2.string().min(1).max(2048), scope: z2.enum(["PLATFORM", "PER_SHOP"]), authMode: z2.enum(["NONE", "BEARER", "API_KEY"]), authHeader: z2.string().min(1).max(128).nullable(), documentation: z2.string().max(16e3), createdAt: z2.iso.datetime({ offset: false }) });
-var ConnectionViewSchema = z2.strictObject({ id: IdSchema, key: z2.string().regex(/^[a-z][a-z0-9_]{0,127}$/), displayName: z2.string().min(1).max(255), description: z2.string().max(4096), enabled: z2.boolean(), editVersion: z2.int().positive(), revisions: z2.array(ConnectionRevisionViewSchema) });
-var CredentialStatusSchema = z2.strictObject({ connectionRevisionId: IdSchema, shopId: IdSchema.nullable(), configured: z2.boolean(), editVersion: z2.int().positive().nullable(), updatedAt: z2.iso.datetime({ offset: false }).nullable() });
-var ConnectionCommandSchema = z2.strictObject({ operationId: IdSchema, reason: z2.string().trim().min(1).max(1e3) });
-var RevisionInputSchema = z2.strictObject({ origin: z2.string().min(1).max(2048), scope: z2.enum(["PLATFORM", "PER_SHOP"]), authMode: z2.enum(["NONE", "BEARER", "API_KEY"]), authHeader: z2.string().min(1).max(128).nullable(), documentation: z2.string().max(16e3) });
-var ConnectionIssueSchema = z2.strictObject({ path: z2.string().max(256), message: z2.string().min(1).max(512) });
-var ConnectionResultSchema = (value) => z2.discriminatedUnion("kind", [
-  z2.strictObject({ kind: z2.literal("ok"), value }),
-  z2.strictObject({ kind: z2.literal("not-found") }),
-  z2.strictObject({ kind: z2.literal("forbidden") }),
-  z2.strictObject({ kind: z2.literal("unavailable") }),
-  z2.strictObject({ kind: z2.literal("invalid"), issues: z2.array(ConnectionIssueSchema).max(32) }),
-  z2.strictObject({ kind: z2.literal("conflict"), code: z2.enum(["STALE_CAS", "CONFLICTING_REPLAY"]) })
+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"]) })
 ]);
 
 // src/commerce/definitions.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 import { gt } from "semver";
 
 // src/commerce/definition-size.ts
@@ -254,53 +362,86 @@ var definitionFitsStorage = (value) => {
 var DEFINITION_SIZE_MESSAGE = "Definition exceeds the 65536-byte jsonb text limit";
 
 // src/commerce/definitions.ts
-var ToolNameSchema = z3.string().regex(/^[a-z][a-z0-9_]{0,127}$/).refine((n) => n !== "finalResponse");
-var PublishedGrantedToolSchema = z3.strictObject({
+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({
+  purpose: CommerceExecutionPurposeSchema,
+  featureId: IdSchema,
+  releaseId: IdSchema,
+  behaviourPrompt: z4.string().refine((value) => new TextEncoder().encode(value).length <= 32768),
+  capabilities: z4.array(z4.strictObject({
+    capabilityId: IdSchema,
+    toolId: IdSchema,
+    revisionId: IdSchema,
+    name: ToolNameSchema,
+    position: z4.number().int().nonnegative(),
+    inputSchema: InputSchemaSchema,
+    outputSchema: CommercePurposeOutputSchemaSchema
+  })).min(1, { message: "PROFILE_EMPTY" }).max(32)
+}).superRefine((profile, ctx) => {
+  const members = profile.capabilities;
+  if (!distinct(members.map((member) => member.name)) || !distinct(members.map((member) => member.capabilityId)) || members.some((member, index) => index > 0 && member.position <= members[index - 1].position))
+    ctx.addIssue({ code: "custom", message: "Invalid purpose profile membership/order" });
+}).transform((profile) => {
+  const snapshot = structuredClone(profile);
+  const freeze = (value) => {
+    if (value && typeof value === "object") {
+      Object.values(value).forEach(freeze);
+      Object.freeze(value);
+    }
+  };
+  freeze(snapshot);
+  return snapshot;
+});
+function requireCommercePurposeProfile(raw) {
+  return CommercePurposeProfileSchema.parse(raw);
+}
+var PublishedGrantedToolSchema = z4.strictObject({
   toolId: IdSchema,
   toolRevisionId: IdSchema,
   toolName: ToolNameSchema,
   definitionVersion: SemverSchema,
-  capabilityKeys: z3.array(IdSchema).min(1).max(32).refine((v) => distinct(v) && v.join("\0") === [...v].sort().join("\0"))
+  capabilityKeys: z4.array(IdSchema).min(1).max(32).refine((v) => distinct(v) && v.join("\0") === [...v].sort().join("\0"))
 });
-var PublishedToolDescriptorSchema = z3.strictObject({
+var PublishedToolDescriptorSchema = z4.strictObject({
   toolId: IdSchema,
   toolRevisionId: IdSchema,
   name: ToolNameSchema,
   definitionVersion: SemverSchema,
-  description: z3.string().min(1).max(4096),
+  description: z4.string().min(1).max(4096),
   inputSchema: InputSchemaSchema
 });
-var CommerceBuiltInToolNameSchema = z3.enum([
+var CommerceBuiltInToolNameSchema = z4.enum([
   "commerce_get_discount_options",
   "commerce_get_discount_details"
 ]).meta({ maxLength: 29 });
-var CommerceBuiltInToolGrantSchema = z3.strictObject({
-  kind: z3.enum(["BUILT_IN"]).meta({ maxLength: 8 }),
+var CommerceBuiltInToolGrantSchema = z4.strictObject({
+  kind: z4.enum(["BUILT_IN"]).meta({ maxLength: 8 }),
   toolName: CommerceBuiltInToolNameSchema,
-  definitionVersion: z3.enum(["2.0.0"]).meta({ maxLength: 5 })
+  definitionVersion: z4.enum(["2.0.0"]).meta({ maxLength: 5 })
 });
-var CommerceBuiltInToolDescriptorSchema = z3.strictObject({
-  kind: z3.enum(["BUILT_IN"]).meta({ maxLength: 8 }),
+var CommerceBuiltInToolDescriptorSchema = z4.strictObject({
+  kind: z4.enum(["BUILT_IN"]).meta({ maxLength: 8 }),
   name: CommerceBuiltInToolNameSchema,
-  definitionVersion: z3.enum(["2.0.0"]).meta({ maxLength: 5 }),
-  description: z3.string().min(1).max(4096),
+  definitionVersion: z4.enum(["2.0.0"]).meta({ maxLength: 5 }),
+  description: z4.string().min(1).max(4096),
   inputSchema: InputSchemaSchema
 });
-var GrantedToolSchema = z3.union([PublishedGrantedToolSchema, CommerceBuiltInToolGrantSchema]);
-var ToolDescriptorSchema = z3.union([PublishedToolDescriptorSchema, CommerceBuiltInToolDescriptorSchema]);
-var GrantedToolsSchema = z3.array(GrantedToolSchema).max(32).refine((values) => {
+var GrantedToolSchema = z4.union([PublishedGrantedToolSchema, CommerceBuiltInToolGrantSchema]);
+var ToolDescriptorSchema = z4.union([PublishedToolDescriptorSchema, CommerceBuiltInToolDescriptorSchema]);
+var GrantedToolsSchema = z4.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 = z3.union([
-  z3.strictObject({
-    input: z3.string().refine(safeName),
-    omitIfMissing: z3.literal(true).optional()
+var MappingSchema = z4.union([
+  z4.strictObject({
+    input: z4.string().refine(safeName),
+    omitIfMissing: z4.literal(true).optional()
   }),
-  z3.strictObject({ literal: boundedJson(8192) })
+  z4.strictObject({ literal: boundedJson(8192) })
 ]);
-var MappingsSchema = z3.record(z3.string().refine(safeName), MappingSchema).refine((v) => Object.keys(v).length <= 32);
+var MappingsSchema = z4.record(z4.string().refine(safeName), MappingSchema).refine((v) => Object.keys(v).length <= 32);
 var POLICY_OPERATIONS = [
   "taxonomy.resolveCategories",
   "products.search",
@@ -314,15 +455,15 @@ var POLICY_OPERATIONS = [
   "products.findQualifying",
   "products.findSimilar"
 ];
-var ExternalHttpExecutionSchema = z3.strictObject({
-  kind: z3.literal("EXTERNAL_HTTP"),
-  executorVersion: z3.literal("1.0.0"),
+var ExternalHttpExecutionSchema = z4.strictObject({
+  kind: z4.literal("EXTERNAL_HTTP"),
+  executorVersion: z4.literal("1.0.0"),
   connectionRevisionId: IdSchema,
-  method: z3.literal("GET"),
+  method: z4.literal("GET"),
   path: ExternalPathSchema,
   query: ExternalQueryMappingsSchema,
   responseFormat: ExternalResponseFormatSchema,
-  resultPath: z3.string().refine((value) => value === "" || safePath(value)),
+  resultPath: z4.string().refine((value) => value === "" || safePath(value)),
   responseProcessing: ResponseProcessingSchema,
   resultSchema: DetailsSchemaSchema
 }).superRefine((value, ctx) => {
@@ -331,21 +472,21 @@ var ExternalHttpExecutionSchema = z3.strictObject({
   if (value.responseProcessing.kind !== "JAVASCRIPT" && value.responseFormat.mode !== "JSON")
     ctx.addIssue({ code: "custom", path: ["responseFormat", "mode"], message: "Visual processing requires JSON" });
 });
-var CommerceExecutionSchema = z3.discriminatedUnion("kind", [
-  z3.strictObject({
-    kind: z3.literal("SHOPIFY_STOREFRONT_QUERY"),
-    executorVersion: z3.literal("1.0.0"),
-    apiVersion: z3.literal("2026-07"),
+var CommerceExecutionSchema = z4.discriminatedUnion("kind", [
+  z4.strictObject({
+    kind: z4.literal("SHOPIFY_STOREFRONT_QUERY"),
+    executorVersion: z4.literal("1.0.0"),
+    apiVersion: z4.literal("2026-07"),
     schemaHash: HashSchema,
-    document: z3.string().min(1).refine((v) => new TextEncoder().encode(v).length <= 16384),
-    operationName: z3.string().refine(safeName),
+    document: z4.string().min(1).refine((v) => new TextEncoder().encode(v).length <= 16384),
+    operationName: z4.string().refine(safeName),
     variables: MappingsSchema,
-    resultPath: z3.string().refine(safePath)
+    resultPath: z4.string().refine(safePath)
   }),
-  z3.strictObject({
-    kind: z3.literal("POLICY_OPERATION"),
-    operation: z3.enum(POLICY_OPERATIONS),
-    operationVersion: z3.literal("1.0.0"),
+  z4.strictObject({
+    kind: z4.literal("POLICY_OPERATION"),
+    operation: z4.enum(POLICY_OPERATIONS),
+    operationVersion: z4.literal("1.0.0"),
     arguments: MappingsSchema
   }),
   ExternalHttpExecutionSchema
@@ -358,17 +499,17 @@ function tokensValid(text, root) {
   );
   return !residue.includes("{{") && !residue.includes("}}");
 }
-var fixed = z3.string().max(4096).refine((v) => !/[<>]|\{\{|\}\}/.test(v));
-var ResponseTemplateSchema = z3.discriminatedUnion("kind", [
-  z3.strictObject({
-    kind: z3.literal("text"),
-    text: z3.string().max(4096).refine((v) => tokensValid(v, "result")),
+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")),
     unavailable: fixed
   }),
-  z3.strictObject({
-    kind: z3.literal("items"),
-    itemsPath: z3.string().refine(safePath),
-    item: z3.string().max(4096).refine((v) => tokensValid(v, "item")),
+  z4.strictObject({
+    kind: z4.literal("items"),
+    itemsPath: z4.string().refine(safePath),
+    item: z4.string().max(4096).refine((v) => tokensValid(v, "item")),
     empty: fixed,
     unavailable: fixed
   })
@@ -376,11 +517,11 @@ var ResponseTemplateSchema = z3.discriminatedUnion("kind", [
 var identity = {
   name: ToolNameSchema,
   definitionVersion: SemverSchema,
-  description: z3.string().min(1).max(4096)
+  description: z4.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 = z3.strictObject({
+var CommerceToolDefinitionSchema = z4.strictObject({
   ...identity,
   inputSchema: InputSchemaSchema,
   execution: CommerceExecutionSchema,
@@ -416,7 +557,7 @@ var CommerceToolDefinitionSchema = z3.strictObject({
 var draftObject = boundedJson(65536).refine(
   (v) => !!v && typeof v === "object" && !Array.isArray(v)
 );
-var CommerceToolDraftDefinitionSchema = z3.strictObject({
+var CommerceToolDraftDefinitionSchema = z4.strictObject({
   ...identity,
   inputSchema: draftObject,
   execution: draftObject,
@@ -509,12 +650,12 @@ function validateDefinitionVersion(proposed, highestPublished) {
   SemverSchema.parse(highestPublished);
   return gt(proposed, highestPublished);
 }
-var CommerceToolIdentitySchema = z3.strictObject({
+var CommerceToolIdentitySchema = z4.strictObject({
   id: IdSchema,
   name: ToolNameSchema,
-  enabled: z3.boolean()
+  enabled: z4.boolean()
 });
-var CommerceToolRevisionIdentitySchema = z3.strictObject({
+var CommerceToolRevisionIdentitySchema = z4.strictObject({
   toolId: IdSchema,
   toolRevisionId: IdSchema,
   definitionVersion: SemverSchema,
@@ -566,10 +707,10 @@ function isTrustedCommerceBuiltInGrant(value) {
 }
 
 // src/commerce/response.ts
-import { z as z4 } from "zod";
-var CommerceResponseContractSchema = z4.strictObject({
-  version: z4.literal("response.v1"),
-  instructions: z4.string().min(1).max(8e3),
+import { z as z5 } from "zod";
+var CommerceResponseContractSchema = z5.strictObject({
+  version: z5.literal("response.v1"),
+  instructions: z5.string().min(1).max(8e3),
   detailsSchema: DetailsSchemaSchema
 }).refine((v) => jsonBytes(v) <= 32768);
 var EMPTY_RESPONSE_CONTRACT = {
@@ -582,31 +723,31 @@ var EMPTY_RESPONSE_CONTRACT = {
     additionalProperties: false
   }
 };
-var ReferralReasonSchema = z4.enum([
+var ReferralReasonSchema = z5.enum([
   "INSUFFICIENT_TOOLS",
   "UNVERIFIABLE_FACTS",
   "TOOL_UNAVAILABLE",
   "TOOL_REVOKED"
 ]);
-var DetectedLanguageTagSchema = z4.string().min(1).max(128).transform((value, ctx) => {
+var DetectedLanguageTagSchema = z5.string().min(1).max(128).transform((value, ctx) => {
   const canonical = canonicaliseLanguageTag(value);
   if (!canonical) {
     ctx.addIssue({
       code: "custom",
       message: "Invalid detected language tag"
     });
-    return z4.NEVER;
+    return z5.NEVER;
   }
   return canonical;
 });
-var CommerceFinalResponseSchema = z4.strictObject({
-  answerKind: z4.enum(["ANSWER", "REFER_TO_STORE"]),
-  replyText: z4.string().min(1).max(4096),
+var CommerceFinalResponseSchema = z5.strictObject({
+  answerKind: z5.enum(["ANSWER", "REFER_TO_STORE"]),
+  replyText: z5.string().min(1).max(4096),
   referralReason: ReferralReasonSchema.nullable(),
   detectedLanguageTag: DetectedLanguageTagSchema.nullable(),
-  detectedLanguageConfidence: z4.number().min(0).max(1).nullable(),
-  evidenceIds: z4.array(IdSchema).max(3).refine((v) => new Set(v).size === v.length),
-  details: z4.record(z4.string(), z4.unknown()).refine((v) => {
+  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) => {
     try {
       return jsonBytes(v) <= 16384;
     } catch {
@@ -742,27 +883,30 @@ function finalResponseToolSchema(definition) {
 }
 
 // src/commerce/schemas.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 import { validRange } from "semver";
-var CommerceTurnIdentitySchema = z5.strictObject({
+var CommerceTurnIdentitySchema = z6.strictObject({
   contractVersion: ContractVersionSchema,
   shopId: IdSchema,
   checkoutRecoveryId: IdSchema,
   conversationId: IdSchema,
-  inboundVersion: z5.number().int().positive()
+  inboundVersion: z6.number().int().positive()
 });
-var CommerceConversationGrantSchema = z5.strictObject({
+var CommerceConversationGrantSchema = z6.strictObject({
   id: IdSchema,
   shopId: IdSchema,
   conversationId: IdSchema,
-  initialInboundVersion: z5.number().int().positive(),
+  initialInboundVersion: z6.number().int().positive(),
   releaseId: IdSchema,
-  selectedCapabilityKeys: z5.array(IdSchema).max(32).refine(distinct),
+  selectedCapabilityKeys: z6.array(IdSchema).max(32).refine(distinct),
+  purposeProfile: CommercePurposeProfileSchema.optional(),
   grantedTools: GrantedToolsSchema,
   runnerVersion: SemverSchema,
   createdAt: DateSchema,
   expiresAt: DateSchema.nullable()
 }).superRefine((v, c) => {
+  if (v.purposeProfile && (v.purposeProfile.releaseId !== v.releaseId || v.purposeProfile.capabilities.some((member) => !v.grantedTools.some((tool) => !isBuiltInTool(tool) && tool.toolId === member.toolId && tool.toolRevisionId === member.revisionId && tool.toolName === member.name))))
+    c.addIssue({ code: "custom", message: "Purpose profile grant mismatch" });
   if (v.expiresAt && Date.parse(v.expiresAt) <= Date.parse(v.createdAt))
     c.addIssue({ code: "custom", message: "Invalid grant retention date" });
   if (jsonBytes(v.grantedTools) > 65536 || jsonBytes(v.selectedCapabilityKeys) > 8192 || v.grantedTools.some(
@@ -770,33 +914,36 @@ var CommerceConversationGrantSchema = z5.strictObject({
   ))
     c.addIssue({ code: "custom", message: "Unselected grant provenance" });
 });
-var CommerceManifestSchema = z5.strictObject({
+var CommerceManifestSchema = z6.strictObject({
   contractVersion: ContractVersionSchema,
   releaseId: IdSchema,
-  runnerCompatibility: z5.string().min(1).max(128).refine((v) => !!validRange(v)),
-  capabilities: z5.array(
-    z5.strictObject({
+  runnerCompatibility: z6.string().min(1).max(128).refine((v) => !!validRange(v)),
+  capabilities: z6.array(
+    z6.strictObject({
       capabilityId: IdSchema,
       key: IdSchema,
       featureId: IdSchema,
-      position: z5.number().int().nonnegative(),
+      position: z6.number().int().nonnegative(),
       toolDescriptor: PublishedToolDescriptorSchema
     })
   ).max(32),
-  featureBehaviours: z5.array(
-    z5.strictObject({
+  featureBehaviours: z6.array(
+    z6.strictObject({
       featureId: IdSchema,
-      behaviourPrompt: z5.string().max(32e3)
+      behaviourPrompt: z6.string().max(32e3)
     })
   ).max(32),
-  selectedCapabilityKeys: z5.array(IdSchema).max(32).refine(distinct),
-  builtInTools: z5.array(CommerceBuiltInToolDescriptorSchema).max(2).default([]),
+  selectedCapabilityKeys: z6.array(IdSchema).max(32).refine(distinct),
+  builtInTools: z6.array(CommerceBuiltInToolDescriptorSchema).max(2).default([]),
+  purposeProfile: CommercePurposeProfileSchema.optional(),
   grantedTools: GrantedToolsSchema,
   responseContract: CommerceResponseContractSchema,
   responseContractHash: HashSchema
 }).superRefine((v, c) => {
   if (jsonBytes(v) > 262144)
     c.addIssue({ code: "custom", message: "Manifest exceeds output limit" });
+  if (v.purposeProfile && (v.purposeProfile.releaseId !== v.releaseId || v.purposeProfile.capabilities.some((member) => !v.capabilities.some((capability) => capability.capabilityId === member.capabilityId && capability.toolDescriptor.toolId === member.toolId && capability.toolDescriptor.toolRevisionId === member.revisionId && capability.toolDescriptor.name === member.name && canonicalJson(capability.toolDescriptor.inputSchema) === canonicalJson(member.inputSchema)))))
+    c.addIssue({ code: "custom", message: "Purpose profile release membership mismatch" });
   const keys = v.capabilities.map((x) => x.key);
   const capabilityIds = v.capabilities.map((x) => x.capabilityId);
   const representedFeatures = [...new Set(v.capabilities.map((x) => x.featureId))];
@@ -842,32 +989,32 @@ var CommerceManifestSchema = z5.strictObject({
       message: "Grant must equal selected capability set"
     });
 });
-var CommerceReleaseIdentitySchema = z5.strictObject({
+var CommerceReleaseIdentitySchema = z6.strictObject({
   contractVersion: ContractVersionSchema,
   releaseId: IdSchema,
-  runnerCompatibility: z5.string().min(1).max(128).refine((v) => !!validRange(v))
+  runnerCompatibility: z6.string().min(1).max(128).refine((v) => !!validRange(v))
 });
 var CommerceResolveAssertionSchema = CommerceTurnIdentitySchema.extend(
-  { purpose: z5.literal("resolve") }
+  { purpose: z6.literal("resolve") }
 );
 var CommerceExecuteAssertionSchema = CommerceTurnIdentitySchema.extend(
-  { purpose: z5.literal("execute"), grantId: IdSchema, releaseId: IdSchema }
+  { purpose: z6.literal("execute"), grantId: IdSchema, releaseId: IdSchema }
 );
-var CommerceAssertionSchema = z5.discriminatedUnion("purpose", [
+var CommerceAssertionSchema = z6.discriminatedUnion("purpose", [
   CommerceResolveAssertionSchema,
   CommerceExecuteAssertionSchema
 ]);
-var qty = z5.number().int().min(1).max(999);
-var CommerceProposalSchema = z5.strictObject({
-  operations: z5.array(
-    z5.discriminatedUnion("kind", [
-      z5.strictObject({
-        kind: z5.literal("ADD"),
+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"),
         variantId: IdSchema,
         quantity: qty
       }),
-      z5.strictObject({
-        kind: z5.literal("REPLACE"),
+      z6.strictObject({
+        kind: z6.literal("REPLACE"),
         lineId: IdSchema,
         variantId: IdSchema,
         quantity: qty
@@ -879,13 +1026,13 @@ var CommerceProposalSchema = z5.strictObject({
     v.operations.flatMap((o) => o.kind === "REPLACE" ? [o.lineId] : [])
   )
 );
-var CommerceBasketSchema = z5.strictObject({
+var CommerceBasketSchema = z6.strictObject({
   basketId: IdSchema,
-  source: z5.enum(["RECOVERY_SNAPSHOT", "PROPOSED"]),
+  source: z6.enum(["RECOVERY_SNAPSHOT", "PROPOSED"]),
   observedAt: DateSchema,
   currency: CurrencySchema.nullable(),
-  lines: z5.array(
-    z5.strictObject({
+  lines: z6.array(
+    z6.strictObject({
       lineId: IdSchema,
       productId: IdSchema.nullable(),
       variantId: IdSchema.nullable(),
@@ -894,35 +1041,35 @@ var CommerceBasketSchema = z5.strictObject({
     })
   ).max(100),
   fingerprint: HashSchema,
-  unknownFields: z5.array(z5.string().min(1).max(256)).max(128)
+  unknownFields: z6.array(z6.string().min(1).max(256)).max(128)
 }).refine((v) => distinct(v.lines.map((line) => line.lineId)));
-var CommerceProductSaleEvidenceSchema = z5.strictObject({
+var CommerceProductSaleEvidenceSchema = z6.strictObject({
   regularPrice: MoneySchema.nullable(),
   salePrice: MoneySchema.nullable(),
   observedAt: DateSchema
 });
-var CommerceProductSchema = z5.strictObject({
+var CommerceProductSchema = z6.strictObject({
   productId: IdSchema,
   variantId: IdSchema.nullable(),
-  title: z5.string().min(1).max(512),
-  url: z5.url({ protocol: /^https$/ }).refine((v) => {
+  title: z6.string().min(1).max(512),
+  url: z6.url({ protocol: /^https$/ }).refine((v) => {
     const u = new URL(v);
     return !u.username && !u.password && !u.port;
   }).nullable(),
-  available: z5.boolean().nullable(),
+  available: z6.boolean().nullable(),
   unitPrice: MoneySchema.nullable(),
   currency: CurrencySchema.nullable(),
-  productType: z5.string().max(512).nullable(),
-  vendor: z5.string().max(512).nullable(),
-  categories: z5.array(z5.string()).optional(),
-  categoryIds: z5.array(IdSchema).max(128).optional(),
-  collectionIds: z5.array(IdSchema).max(128).optional(),
-  imageUrl: z5.string().nullable().optional(),
+  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(),
   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 = z5.string().regex(discountUtcPattern).refine((value) => {
+var CommerceDiscountDateTimeSchema = z6.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);
@@ -931,36 +1078,36 @@ var CommerceDiscountDateTimeSchema = z5.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 = z5.strictObject({
+var CommerceOfferSchema = z6.strictObject({
   offerId: IdSchema,
-  title: z5.string().min(1).max(512),
-  method: z5.enum(["AUTOMATIC", "CODE"]),
-  code: z5.string().min(1).max(128).nullable(),
+  title: z6.string().min(1).max(512),
+  method: z6.enum(["AUTOMATIC", "CODE"]),
+  code: z6.string().min(1).max(128).nullable(),
   startsAt: CommerceDiscountDateTimeSchema.nullable(),
   endsAt: CommerceDiscountDateTimeSchema.nullable(),
-  support: z5.enum(["SUPPORTED", "UNSUPPORTED", "UNKNOWN"]),
-  reasonCodes: z5.array(z5.string().min(1).max(64)).max(16)
+  support: z6.enum(["SUPPORTED", "UNSUPPORTED", "UNKNOWN"]),
+  reasonCodes: z6.array(z6.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 = z5.strictObject({
-  discountClasses: z5.array(z5.enum(["ORDER", "PRODUCT", "SHIPPING"])).max(3).nullable(),
-  shopifyPlus: z5.boolean().nullable(),
-  combinesWith: z5.strictObject({
-    orderDiscounts: z5.boolean().nullable(),
-    productDiscounts: z5.boolean().nullable(),
-    shippingDiscounts: z5.boolean().nullable()
+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()
   }).nullable(),
-  discountTags: z5.array(z5.string().min(1).max(128)).max(64).nullable(),
-  allowedSameLineProductTags: z5.array(z5.string().min(1).max(128)).max(64).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()
 });
-var CommerceDiscountConditionFactsSchema = z5.strictObject({
-  provider: z5.enum(["SHOPIFY", "WOOCOMMERCE"]),
-  completeness: z5.enum(["COMPLETE", "PARTIAL", "UNKNOWN"]),
+var CommerceDiscountConditionFactsSchema = z6.strictObject({
+  provider: z6.enum(["SHOPIFY", "WOOCOMMERCE"]),
+  completeness: z6.enum(["COMPLETE", "PARTIAL", "UNKNOWN"]),
   observedAt: CommerceDiscountDateTimeSchema,
-  providerStatus: z5.string().max(64),
+  providerStatus: z6.string().max(64),
   unavailableAt: CommerceDiscountDateTimeSchema.nullable(),
-  discountKind: z5.enum([
+  discountKind: z6.enum([
     "PERCENTAGE",
     "FIXED_AMOUNT",
     "FREE_SHIPPING",
@@ -970,8 +1117,8 @@ var CommerceDiscountConditionFactsSchema = z5.strictObject({
   ]),
   discountValue: MoneySchema.nullable(),
   discountCurrency: CurrencySchema.nullable(),
-  targeting: z5.strictObject({
-    kind: z5.enum([
+  targeting: z6.strictObject({
+    kind: z6.enum([
       "ALL",
       "PRODUCTS",
       "VARIANTS",
@@ -980,38 +1127,38 @@ var CommerceDiscountConditionFactsSchema = z5.strictObject({
       "MIXED",
       "UNKNOWN"
     ]),
-    includedProductIds: z5.array(IdSchema).max(128),
-    includedVariantIds: z5.array(IdSchema).max(128),
-    includedCategoryIds: z5.array(IdSchema).max(128),
-    includedCollectionIds: z5.array(IdSchema).max(128),
-    excludedProductIds: z5.array(IdSchema).max(128),
-    excludedVariantIds: z5.array(IdSchema).max(128),
-    excludedCategoryIds: z5.array(IdSchema).max(128),
-    excludedCollectionIds: z5.array(IdSchema).max(128)
+    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)
   }),
   minimumSubtotal: MoneySchema.nullable(),
   maximumSubtotal: MoneySchema.nullable(),
   subtotalRequirementCurrency: CurrencySchema.nullable(),
-  minimumQuantity: z5.number().int().nonnegative().nullable(),
-  usageLimit: z5.number().int().nonnegative().nullable(),
-  usageCount: z5.number().int().nonnegative().nullable(),
-  perCustomerLimit: z5.number().int().nonnegative().nullable(),
-  customerScope: z5.enum(["ALL", "RESTRICTED", "UNKNOWN"]),
-  excludesSaleItems: z5.boolean().nullable(),
-  individualUse: z5.boolean().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(),
   combination: CommerceDiscountCombinationFactsSchema,
-  unrepresentedConditions: z5.array(z5.string().min(1).max(128)).max(24)
+  unrepresentedConditions: z6.array(z6.string().min(1).max(128)).max(24)
 });
-var CommerceDiscountDetailsSchema = z5.strictObject({
+var CommerceDiscountDetailsSchema = z6.strictObject({
   offer: CommerceOfferSchema,
   facts: CommerceDiscountConditionFactsSchema,
-  providerDiscountId: z5.string().min(1).max(191).nullable()
+  providerDiscountId: z6.string().min(1).max(191).nullable()
 });
-var condition = z5.strictObject({
-  code: z5.string().min(1).max(64),
-  description: z5.string().max(256)
+var condition = z6.strictObject({
+  code: z6.string().min(1).max(64),
+  description: z6.string().max(256)
 });
-var CommerceEvidenceSchema = z5.strictObject({
+var CommerceEvidenceSchema = z6.strictObject({
   evidenceId: HashSchema,
   turn: CommerceTurnIdentitySchema,
   grantId: IdSchema,
@@ -1022,7 +1169,7 @@ var CommerceEvidenceSchema = z5.strictObject({
   ruleFingerprint: HashSchema,
   evaluatedAt: DateSchema,
   expiresAt: DateSchema,
-  outcome: z5.enum([
+  outcome: z6.enum([
     "QUALIFIES_FOR_KNOWN_RULES",
     "DOES_NOT_QUALIFY",
     "UNKNOWN",
@@ -1031,8 +1178,8 @@ var CommerceEvidenceSchema = z5.strictObject({
   currency: CurrencySchema.nullable(),
   savings: MoneySchema.nullable(),
   resultingTotal: MoneySchema.nullable(),
-  evaluatedConditions: z5.array(condition).max(32),
-  unresolvedConditions: z5.array(condition).max(32)
+  evaluatedConditions: z6.array(condition).max(32),
+  unresolvedConditions: z6.array(condition).max(32)
 }).superRefine((v, c) => {
   if (Date.parse(v.expiresAt) - Date.parse(v.evaluatedAt) > 6e4)
     c.addIssue({
@@ -1042,16 +1189,16 @@ var CommerceEvidenceSchema = z5.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 = z5.strictObject({
+var CommerceAlternativeSchema = z6.strictObject({
   product: CommerceProductSchema,
   proposal: CommerceProposalSchema,
   extraSpend: MoneySchema.nullable(),
   resultingTotal: MoneySchema.nullable(),
   currency: CurrencySchema.nullable(),
   evidence: CommerceEvidenceSchema.nullable(),
-  similarityReasons: z5.array(z5.string().max(256)).max(3)
+  similarityReasons: z6.array(z6.string().max(256)).max(3)
 }).refine((v) => v.product.available === true);
-var CommerceErrorCodeSchema = z5.enum([
+var CommerceErrorCodeSchema = z6.enum([
   "INVALID_INPUT",
   "DENIED",
   "STALE_TURN",
@@ -1062,182 +1209,182 @@ var CommerceErrorCodeSchema = z5.enum([
   "INCOMPATIBLE_VERSION"
 ]);
 function commerceToolResultSchema(data) {
-  return z5.union([
-    z5.strictObject({
+  return z6.union([
+    z6.strictObject({
       contractVersion: ContractVersionSchema,
-      status: z5.literal("OK"),
+      status: z6.literal("OK"),
       data,
-      renderedText: z5.string().max(4096)
+      renderedText: z6.string().max(4096)
     }),
-    z5.strictObject({
+    z6.strictObject({
       contractVersion: ContractVersionSchema,
-      status: z5.literal("ERROR"),
+      status: z6.literal("ERROR"),
       code: CommerceErrorCodeSchema,
-      retryable: z5.boolean(),
-      renderedText: z5.string().max(4096).optional()
+      retryable: z6.boolean(),
+      renderedText: z6.string().max(4096).optional()
     })
   ]);
 }
 var CommerceToolResultSchema = commerceToolResultSchema(
   boundedJson(262144)
 );
-var wireId = z5.string().min(1).max(128);
-var taxonomySource = z5.enum(["SHOPIFY_STANDARD_PRODUCT_TAXONOMY"]).meta({ maxLength: 33 });
-var CommerceCategoryCandidateSchema = z5.strictObject({
+var wireId = z6.string().min(1).max(128);
+var taxonomySource = z6.enum(["SHOPIFY_STANDARD_PRODUCT_TAXONOMY"]).meta({ maxLength: 33 });
+var CommerceCategoryCandidateSchema = z6.strictObject({
   categoryId: wireId,
-  name: z5.string().min(1).max(512),
-  fullName: z5.string().min(1).max(4096),
+  name: z6.string().min(1).max(512),
+  fullName: z6.string().min(1).max(4096),
   parentId: wireId.nullable(),
-  level: z5.number().int().min(0).max(32),
-  ancestorIds: z5.array(wireId).max(32),
-  distance: z5.number().min(0).max(2)
+  level: z6.number().int().min(0).max(32),
+  ancestorIds: z6.array(wireId).max(32),
+  distance: z6.number().min(0).max(2)
 });
-var CommerceCategoryResolutionSchema = z5.union([
-  z5.strictObject({
-    outcome: z5.enum(["CANDIDATES", "NO_CANDIDATES"]).meta({ maxLength: 13 }),
+var CommerceCategoryResolutionSchema = z6.union([
+  z6.strictObject({
+    outcome: z6.enum(["CANDIDATES", "NO_CANDIDATES"]).meta({ maxLength: 13 }),
     generationId: wireId,
     source: taxonomySource,
-    taxonomyVersion: z5.string().min(1).max(64),
-    languageTag: z5.string().min(1).max(35),
-    candidates: z5.array(CommerceCategoryCandidateSchema).max(10)
+    taxonomyVersion: z6.string().min(1).max(64),
+    languageTag: z6.string().min(1).max(35),
+    candidates: z6.array(CommerceCategoryCandidateSchema).max(10)
   }),
-  z5.strictObject({
-    outcome: z5.enum(["UNAVAILABLE"]).meta({ maxLength: 11 }),
-    reasonCode: z5.enum(["NOT_READY", "TEMPORARY_UNAVAILABLE"]).meta({ maxLength: 21 })
+  z6.strictObject({
+    outcome: z6.enum(["UNAVAILABLE"]).meta({ maxLength: 11 }),
+    reasonCode: z6.enum(["NOT_READY", "TEMPORARY_UNAVAILABLE"]).meta({ maxLength: 21 })
   })
 ]);
-var CommerceOptionalLookupUnavailableSchema = z5.strictObject({
-  outcome: z5.enum(["UNAVAILABLE"]).meta({ maxLength: 11 }),
-  reasonCode: z5.enum(["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 CommerceProductRecommendationSelectionSchema = z5.strictObject({
-  productRecommendationVersion: z5.enum(["1"]).meta({ maxLength: 1 }).optional(),
-  productRecommendations: z5.array(z5.strictObject({
-    scope: z5.enum(["PRODUCT_ONLY", "ADD_TO_BASKET", "REPLACE_BASKET_LINE"]).meta({ maxLength: 19 }),
+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 }),
     basketLineId: wireId.nullable(),
     productId: wireId,
     variantId: wireId.nullable(),
-    quantity: z5.number().int().min(1).max(99),
-    promotionKind: z5.enum(["NONE", "NATIVE_SALE", "DISCOUNT"]).meta({ maxLength: 11 }),
-    offerIds: z5.array(wireId).max(3)
+    quantity: z6.number().int().min(1).max(99),
+    promotionKind: z6.enum(["NONE", "NATIVE_SALE", "DISCOUNT"]).meta({ maxLength: 11 }),
+    offerIds: z6.array(wireId).max(3)
   })).min(1).max(3).optional()
 });
-var CommerceResponseDispositionSchema = z5.enum([
+var CommerceResponseDispositionSchema = z6.enum([
   "STANDARD",
   "OUT_OF_SCOPE_REDIRECT",
   "SHIPPING_INFORMATION_UNVERIFIED"
 ]).meta({ maxLength: 31 });
-var CommerceAnswerPresentationSelectionSchema = z5.strictObject({
+var CommerceAnswerPresentationSelectionSchema = z6.strictObject({
   responseDisposition: CommerceResponseDispositionSchema.optional(),
-  shippingInformationSelection: z5.strictObject({
+  shippingInformationSelection: z6.strictObject({
     productId: wireId.nullable(),
     variantId: wireId.nullable()
   }).optional()
 });
-var CommerceShippingInformationInputSchema = z5.strictObject({
+var CommerceShippingInformationInputSchema = z6.strictObject({
   productId: wireId.nullable().default(null),
   variantId: wireId.nullable().default(null)
 });
-var CommerceShippingInformationSchema = z5.strictObject({
-  provider: z5.enum(["SHOPIFY", "WOOCOMMERCE"]).meta({ maxLength: 11 }),
+var CommerceShippingInformationSchema = z6.strictObject({
+  provider: z6.enum(["SHOPIFY", "WOOCOMMERCE"]).meta({ maxLength: 11 }),
   observedAt: DateSchema,
-  product: z5.strictObject({
-    status: z5.enum(["NOT_REQUESTED", "VARIANT_REQUIRED", "AVAILABLE"]).meta({ maxLength: 16 }),
+  product: z6.strictObject({
+    status: z6.enum(["NOT_REQUESTED", "VARIANT_REQUIRED", "AVAILABLE"]).meta({ maxLength: 16 }),
     productId: wireId.nullable(),
     variantId: wireId.nullable(),
-    requiresShipping: z5.boolean().nullable(),
-    virtual: z5.boolean().nullable(),
-    weight: z5.strictObject({
-      value: z5.number().min(0),
-      unit: z5.enum(["GRAMS", "KILOGRAMS", "OUNCES", "POUNDS"]).meta({ maxLength: 9 }).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()
     }).nullable(),
-    dimensions: z5.strictObject({
-      length: z5.number().min(0).nullable(),
-      width: z5.number().min(0).nullable(),
-      height: z5.number().min(0).nullable(),
-      unit: z5.string().min(1).max(16).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()
     }).nullable(),
     shippingClassId: wireId.nullable(),
-    shippingClassSlug: z5.string().min(1).max(512).nullable()
+    shippingClassSlug: z6.string().min(1).max(512).nullable()
   }),
-  policy: z5.strictObject({
-    status: z5.enum(["AVAILABLE", "NOT_CONFIGURED", "SCOPE_NOT_GRANTED", "UNSUPPORTED"]).meta({ maxLength: 17 }),
-    trust: z5.enum(["UNTRUSTED_REFERENCE"]).meta({ maxLength: 19 }),
-    title: z5.string().min(1).max(512).nullable(),
-    bodyStatus: z5.enum(["AVAILABLE", "EMPTY", "TOO_LARGE", "NOT_AVAILABLE"]).meta({ maxLength: 13 }),
-    bodyHtml: z5.string().min(1).max(8e3).nullable(),
-    url: z5.url({ protocol: /^https$/ }).min(1).max(2048).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(),
     updatedAt: DateSchema.nullable()
   })
 });
-var limit = z5.number().int().min(1).max(3).default(3);
+var limit = z6.number().int().min(1).max(3).default(3);
 var CommerceToolInputs = {
-  commerce_resolve_product_categories: z5.strictObject({
-    query: z5.string().min(1).max(200),
-    limit: z5.number().int().min(1).max(10).default(5)
+  commerce_resolve_product_categories: z6.strictObject({
+    query: z6.string().min(1).max(200),
+    limit: z6.number().int().min(1).max(10).default(5)
   }),
   commerce_get_shipping_information: CommerceShippingInformationInputSchema,
-  commerce_get_basket: z5.strictObject({}),
-  commerce_search_products: z5.strictObject({
-    query: z5.string().min(1).max(200).nullable().default(null),
-    category: z5.strictObject({
-      system: z5.enum(["SHOPIFY_STANDARD_PRODUCT_TAXONOMY", "WOOCOMMERCE_PRODUCT_CATEGORY"]).meta({ maxLength: 33 }),
+  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 }),
       id: wireId,
-      taxonomyVersion: z5.string().min(1).max(64).nullable()
+      taxonomyVersion: z6.string().min(1).max(64).nullable()
     }).optional(),
-    browse: z5.boolean().default(false),
+    browse: z6.boolean().default(false),
     maximumPrice: MoneySchema.optional(),
-    availableOnly: z5.boolean().default(true),
-    limit: z5.number().int().min(1).max(20).default(10),
-    cursor: z5.string().max(2048).nullable().default(null)
+    availableOnly: z6.boolean().default(true),
+    limit: z6.number().int().min(1).max(20).default(10),
+    cursor: z6.string().max(2048).nullable().default(null)
   }),
-  commerce_get_product: z5.strictObject({
+  commerce_get_product: z6.strictObject({
     productId: IdSchema,
     variantId: IdSchema.nullable()
   }),
-  commerce_get_discount_options: z5.strictObject({
-    limit: z5.number().int().min(1).max(50).default(20),
-    cursor: z5.string().max(2048).nullable().default(null)
+  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_details: z5.strictObject({ offerId: IdSchema }),
-  commerce_evaluate_discount: z5.strictObject({
+  commerce_get_discount_details: z6.strictObject({ offerId: IdSchema }),
+  commerce_evaluate_discount: z6.strictObject({
     offerId: IdSchema,
     proposal: CommerceProposalSchema.nullable()
   }),
-  commerce_find_qualifying_products: z5.strictObject({
+  commerce_find_qualifying_products: z6.strictObject({
     offerId: IdSchema,
-    query: z5.string().min(1).max(200).nullable(),
+    query: z6.string().min(1).max(200).nullable(),
     limit
   }),
-  commerce_find_similar_products: z5.strictObject({
+  commerce_find_similar_products: z6.strictObject({
     variantId: IdSchema,
     offerId: IdSchema.nullable(),
     limit
   })
 };
-var alternatives = z5.strictObject({
-  alternatives: z5.array(CommerceAlternativeSchema).max(3),
-  truncated: z5.boolean()
+var alternatives = z6.strictObject({
+  alternatives: z6.array(CommerceAlternativeSchema).max(3),
+  truncated: z6.boolean()
 });
 var CommerceToolOutputs = {
   commerce_resolve_product_categories: CommerceCategoryResolutionSchema,
   commerce_get_shipping_information: CommerceShippingInformationSchema,
   commerce_get_basket: CommerceBasketSchema,
-  commerce_search_products: z5.strictObject({
-    products: z5.array(CommerceProductSchema).max(20),
-    cursor: z5.string().max(2048).nullable(),
-    truncated: z5.boolean()
+  commerce_search_products: z6.strictObject({
+    products: z6.array(CommerceProductSchema).max(20),
+    cursor: z6.string().max(2048).nullable(),
+    truncated: z6.boolean()
   }),
-  commerce_get_product: z5.strictObject({
+  commerce_get_product: z6.strictObject({
     product: CommerceProductSchema.nullable()
   }),
-  commerce_get_discount_options: z5.union([CommerceOptionalLookupUnavailableSchema, z5.strictObject({
-    mode: z5.enum(["NONE", "FIXED", "AI_BEST_APPLICABLE"]),
-    offers: z5.array(CommerceOfferSchema).max(50),
-    truncated: z5.boolean(),
-    cursor: z5.string().max(2048).nullable().optional()
+  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_details: z5.union([CommerceOptionalLookupUnavailableSchema, z5.strictObject({
+  commerce_get_discount_details: z6.union([CommerceOptionalLookupUnavailableSchema, z6.strictObject({
     details: CommerceDiscountDetailsSchema.nullable()
   })]),
   commerce_evaluate_discount: CommerceEvidenceSchema,
@@ -1261,6 +1408,9 @@ export {
   DetailsSchemaSchema,
   matchesSubset,
   compileSubset,
+  validateCommercePurposeOutputSchema,
+  CommercePurposeOutputSchemaSchema,
+  compileCommercePurposeOutputSchema,
   ExternalQueryValueSchema,
   ExternalQueryMappingSchema,
   ExternalQueryMappingsSchema,
@@ -1281,6 +1431,9 @@ export {
   ConnectionIssueSchema,
   ConnectionResultSchema,
   ToolNameSchema,
+  CommerceExecutionPurposeSchema,
+  CommercePurposeProfileSchema,
+  requireCommercePurposeProfile,
   PublishedGrantedToolSchema,
   PublishedToolDescriptorSchema,
   CommerceBuiltInToolNameSchema,
@@ -1346,4 +1499,4 @@ export {
   CommerceToolOutputs,
   productBelongsToDomain
 };
-//# sourceMappingURL=chunk-6OBYUIQ3.js.map
+//# sourceMappingURL=chunk-BDGLKOCW.js.map