@modainteract/moda-interact-shared 2.5.1 → 2.7.0

package/dist/{chunk-QJNZJACH.js → chunk-XTKCNFLQ.js}

@@ -1,11 +1,21 @@
+import {
+  ContractVersionSchema,
+  CurrencySchema,
+  DateSchema,
+  HashSchema,
+  IdSchema,
+  MoneySchema,
+  SemverSchema,
+  boundedJson,
+  distinct
+} from "./chunk-QVPEX7KY.js";
 import {
   canonicalJson,
   jsonBytes,
   responseContractCanonicalJson
 } from "./chunk-AUS3WQIW.js";
 import {
-  canonicaliseLanguageTag,
-  normalizeCurrencyCode
+  canonicaliseLanguageTag
 } from "./chunk-4KSODB2R.js";
 
 // src/commerce/subset.ts
@@ -145,73 +155,40 @@ function compileSubset(schema, mode) {
   });
 }
 
-// src/commerce/primitives.ts
-import { z as z2 } from "zod";
-var ContractVersionSchema = z2.literal("commerce.v1");
-var IdSchema = z2.string().min(1).max(128).refine(
-  (v) => v.trim() === v && !["standalone", "product-only", "unknown-shop"].includes(v)
-);
-var SemverSchema = z2.string().max(64).regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/);
-var HashSchema = z2.string().regex(/^[a-f0-9]{64}$/);
-var DateSchema = z2.iso.datetime({ offset: false });
-var MoneySchema = z2.string().regex(/^[0-9]{1,18}(\.[0-9]{1,6})?$/);
-var CurrencySchema = z2.string().refine((v) => {
-  try {
-    return normalizeCurrencyCode(v) === v;
-  } catch {
-    return false;
-  }
-});
-var LanguageSchema = z2.string().max(128).refine((v) => {
-  try {
-    return canonicaliseLanguageTag(v) === v;
-  } catch {
-    return false;
-  }
-});
-var distinct = (values) => new Set(values).size === values.length;
-var boundedJson = (bytes) => z2.unknown().refine((v) => {
-  try {
-    return jsonBytes(v) <= bytes;
-  } catch {
-    return false;
-  }
-});
-
 // src/commerce/external.ts
-import { z as z3 } from "zod";
+import { z as z2 } 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 = z2.union([z2.string().refine((value) => utf8(value, 2048)), z2.number().finite(), z2.boolean()]);
 var ExternalQueryValueSchema = scalar;
-var scalarOrNull = z3.union([scalar, z3.null()]);
-var record = (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 = 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 ExternalQueryMappingsSchema = record(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 = z2.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 = z2.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 = record(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 = 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 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 = 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) => {
   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;
@@ -219,24 +196,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 = 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"]) })
 ]);
 
 // src/commerce/definitions.ts
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 import { gt } from "semver";
 
 // src/commerce/definition-size.ts
@@ -277,33 +254,33 @@ 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 GrantedToolSchema = z4.strictObject({
+var ToolNameSchema = z3.string().regex(/^[a-z][a-z0-9_]{0,127}$/).refine((n) => n !== "finalResponse");
+var GrantedToolSchema = z3.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: z3.array(IdSchema).min(1).max(32).refine((v) => distinct(v) && v.join("\0") === [...v].sort().join("\0"))
 });
-var GrantedToolsSchema = z4.array(GrantedToolSchema).max(32).refine(
+var GrantedToolsSchema = z3.array(GrantedToolSchema).max(32).refine(
   (v) => distinct(v.map((x) => x.toolId)) && distinct(v.map((x) => x.toolName))
 );
-var ToolDescriptorSchema = z4.strictObject({
+var ToolDescriptorSchema = z3.strictObject({
   toolId: IdSchema,
   toolRevisionId: IdSchema,
   name: ToolNameSchema,
   definitionVersion: SemverSchema,
-  description: z4.string().min(1).max(4096),
+  description: z3.string().min(1).max(4096),
   inputSchema: InputSchemaSchema
 });
-var MappingSchema = z4.union([
-  z4.strictObject({
-    input: z4.string().refine(safeName),
-    omitIfMissing: z4.literal(true).optional()
+var MappingSchema = z3.union([
+  z3.strictObject({
+    input: z3.string().refine(safeName),
+    omitIfMissing: z3.literal(true).optional()
   }),
-  z4.strictObject({ literal: boundedJson(8192) })
+  z3.strictObject({ literal: boundedJson(8192) })
 ]);
-var MappingsSchema = z4.record(z4.string().refine(safeName), MappingSchema).refine((v) => Object.keys(v).length <= 32);
+var MappingsSchema = z3.record(z3.string().refine(safeName), MappingSchema).refine((v) => Object.keys(v).length <= 32);
 var POLICY_OPERATIONS = [
   "recovery.getBasket",
   "shopify.searchProducts",
@@ -312,15 +289,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 = z3.strictObject({
+  kind: z3.literal("EXTERNAL_HTTP"),
+  executorVersion: z3.literal("1.0.0"),
   connectionRevisionId: IdSchema,
-  method: z4.literal("GET"),
+  method: z3.literal("GET"),
   path: ExternalPathSchema,
   query: ExternalQueryMappingsSchema,
   responseFormat: ExternalResponseFormatSchema,
-  resultPath: z4.string().refine((value) => value === "" || safePath(value)),
+  resultPath: z3.string().refine((value) => value === "" || safePath(value)),
   responseProcessing: ResponseProcessingSchema,
   resultSchema: DetailsSchemaSchema
 }).superRefine((value, ctx) => {
@@ -329,21 +306,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 = z3.discriminatedUnion("kind", [
+  z3.strictObject({
+    kind: z3.literal("SHOPIFY_STOREFRONT_QUERY"),
+    executorVersion: z3.literal("1.0.0"),
+    apiVersion: z3.literal("2026-07"),
     schemaHash: HashSchema,
-    document: z4.string().min(1).refine((v) => new TextEncoder().encode(v).length <= 16384),
-    operationName: z4.string().refine(safeName),
+    document: z3.string().min(1).refine((v) => new TextEncoder().encode(v).length <= 16384),
+    operationName: z3.string().refine(safeName),
     variables: MappingsSchema,
-    resultPath: z4.string().refine(safePath)
+    resultPath: z3.string().refine(safePath)
   }),
-  z4.strictObject({
-    kind: z4.literal("POLICY_OPERATION"),
-    operation: z4.enum(POLICY_OPERATIONS),
-    operationVersion: z4.literal("1.0.0"),
+  z3.strictObject({
+    kind: z3.literal("POLICY_OPERATION"),
+    operation: z3.enum(POLICY_OPERATIONS),
+    operationVersion: z3.literal("1.0.0"),
     arguments: MappingsSchema
   }),
   ExternalHttpExecutionSchema
@@ -356,17 +333,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 = 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")),
     unavailable: fixed
   }),
-  z4.strictObject({
-    kind: z4.literal("items"),
-    itemsPath: z4.string().refine(safePath),
-    item: z4.string().max(4096).refine((v) => tokensValid(v, "item")),
+  z3.strictObject({
+    kind: z3.literal("items"),
+    itemsPath: z3.string().refine(safePath),
+    item: z3.string().max(4096).refine((v) => tokensValid(v, "item")),
     empty: fixed,
     unavailable: fixed
   })
@@ -374,11 +351,11 @@ var ResponseTemplateSchema = z4.discriminatedUnion("kind", [
 var identity = {
   name: ToolNameSchema,
   definitionVersion: SemverSchema,
-  description: z4.string().min(1).max(4096)
+  description: z3.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 = z3.strictObject({
   ...identity,
   inputSchema: InputSchemaSchema,
   execution: CommerceExecutionSchema,
@@ -414,7 +391,7 @@ var CommerceToolDefinitionSchema = z4.strictObject({
 var draftObject = boundedJson(65536).refine(
   (v) => !!v && typeof v === "object" && !Array.isArray(v)
 );
-var CommerceToolDraftDefinitionSchema = z4.strictObject({
+var CommerceToolDraftDefinitionSchema = z3.strictObject({
   ...identity,
   inputSchema: draftObject,
   execution: draftObject,
@@ -507,12 +484,12 @@ function validateDefinitionVersion(proposed, highestPublished) {
   SemverSchema.parse(highestPublished);
   return gt(proposed, highestPublished);
 }
-var CommerceToolIdentitySchema = z4.strictObject({
+var CommerceToolIdentitySchema = z3.strictObject({
   id: IdSchema,
   name: ToolNameSchema,
-  enabled: z4.boolean()
+  enabled: z3.boolean()
 });
-var CommerceToolRevisionIdentitySchema = z4.strictObject({
+var CommerceToolRevisionIdentitySchema = z3.strictObject({
   toolId: IdSchema,
   toolRevisionId: IdSchema,
   definitionVersion: SemverSchema,
@@ -523,10 +500,10 @@ var POLICY_OPERATION_DESCRIPTORS = POLICY_OPERATIONS.map(
 );
 
 // 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 z4 } from "zod";
+var CommerceResponseContractSchema = z4.strictObject({
+  version: z4.literal("response.v1"),
+  instructions: z4.string().min(1).max(8e3),
   detailsSchema: DetailsSchemaSchema
 }).refine((v) => jsonBytes(v) <= 32768);
 var EMPTY_RESPONSE_CONTRACT = {
@@ -539,31 +516,31 @@ var EMPTY_RESPONSE_CONTRACT = {
     additionalProperties: false
   }
 };
-var ReferralReasonSchema = z5.enum([
+var ReferralReasonSchema = z4.enum([
   "INSUFFICIENT_TOOLS",
   "UNVERIFIABLE_FACTS",
   "TOOL_UNAVAILABLE",
   "TOOL_REVOKED"
 ]);
-var DetectedLanguageTagSchema = z5.string().min(1).max(128).transform((value, ctx) => {
+var DetectedLanguageTagSchema = z4.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 z4.NEVER;
   }
   return canonical;
 });
-var CommerceFinalResponseSchema = z5.strictObject({
-  answerKind: z5.enum(["ANSWER", "REFER_TO_STORE"]),
-  replyText: z5.string().min(1).max(4096),
+var CommerceFinalResponseSchema = z4.strictObject({
+  answerKind: z4.enum(["ANSWER", "REFER_TO_STORE"]),
+  replyText: z4.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: 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) => {
     try {
       return jsonBytes(v) <= 16384;
     } catch {
@@ -699,22 +676,22 @@ function finalResponseToolSchema(definition) {
 }
 
 // src/commerce/schemas.ts
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 import { validRange } from "semver";
-var CommerceTurnIdentitySchema = z6.strictObject({
+var CommerceTurnIdentitySchema = z5.strictObject({
   contractVersion: ContractVersionSchema,
   shopId: IdSchema,
   checkoutRecoveryId: IdSchema,
   conversationId: IdSchema,
-  inboundVersion: z6.number().int().positive()
+  inboundVersion: z5.number().int().positive()
 });
-var CommerceConversationGrantSchema = z6.strictObject({
+var CommerceConversationGrantSchema = z5.strictObject({
   id: IdSchema,
   shopId: IdSchema,
   conversationId: IdSchema,
-  initialInboundVersion: z6.number().int().positive(),
+  initialInboundVersion: z5.number().int().positive(),
   releaseId: IdSchema,
-  selectedCapabilityKeys: z6.array(IdSchema).max(32).refine(distinct),
+  selectedCapabilityKeys: z5.array(IdSchema).max(32).refine(distinct),
   grantedTools: GrantedToolsSchema,
   runnerVersion: SemverSchema,
   createdAt: DateSchema,
@@ -727,26 +704,26 @@ var CommerceConversationGrantSchema = z6.strictObject({
   ))
     c.addIssue({ code: "custom", message: "Unselected grant provenance" });
 });
-var CommerceManifestSchema = z6.strictObject({
+var CommerceManifestSchema = z5.strictObject({
   contractVersion: ContractVersionSchema,
   releaseId: IdSchema,
-  runnerCompatibility: z6.string().min(1).max(128).refine((v) => !!validRange(v)),
-  capabilities: z6.array(
-    z6.strictObject({
+  runnerCompatibility: z5.string().min(1).max(128).refine((v) => !!validRange(v)),
+  capabilities: z5.array(
+    z5.strictObject({
       capabilityId: IdSchema,
       key: IdSchema,
       featureId: IdSchema,
-      position: z6.number().int().nonnegative(),
+      position: z5.number().int().nonnegative(),
       toolDescriptor: ToolDescriptorSchema
     })
   ).max(32),
-  featureBehaviours: z6.array(
-    z6.strictObject({
+  featureBehaviours: z5.array(
+    z5.strictObject({
       featureId: IdSchema,
-      behaviourPrompt: z6.string().max(32e3)
+      behaviourPrompt: z5.string().max(32e3)
     })
   ).max(32),
-  selectedCapabilityKeys: z6.array(IdSchema).max(32).refine(distinct),
+  selectedCapabilityKeys: z5.array(IdSchema).max(32).refine(distinct),
   grantedTools: GrantedToolsSchema,
   responseContract: CommerceResponseContractSchema,
   responseContractHash: HashSchema
@@ -797,32 +774,32 @@ var CommerceManifestSchema = z6.strictObject({
       message: "Grant must equal selected capability set"
     });
 });
-var CommerceReleaseIdentitySchema = z6.strictObject({
+var CommerceReleaseIdentitySchema = z5.strictObject({
   contractVersion: ContractVersionSchema,
   releaseId: IdSchema,
-  runnerCompatibility: z6.string().min(1).max(128).refine((v) => !!validRange(v))
+  runnerCompatibility: z5.string().min(1).max(128).refine((v) => !!validRange(v))
 });
 var CommerceResolveAssertionSchema = CommerceTurnIdentitySchema.extend(
-  { purpose: z6.literal("resolve") }
+  { purpose: z5.literal("resolve") }
 );
 var CommerceExecuteAssertionSchema = CommerceTurnIdentitySchema.extend(
-  { purpose: z6.literal("execute"), grantId: IdSchema, releaseId: IdSchema }
+  { purpose: z5.literal("execute"), grantId: IdSchema, releaseId: IdSchema }
 );
-var CommerceAssertionSchema = z6.discriminatedUnion("purpose", [
+var CommerceAssertionSchema = z5.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 = z5.number().int().min(1).max(999);
+var CommerceProposalSchema = z5.strictObject({
+  operations: z5.array(
+    z5.discriminatedUnion("kind", [
+      z5.strictObject({
+        kind: z5.literal("ADD"),
         variantId: IdSchema,
         quantity: qty
       }),
-      z6.strictObject({
-        kind: z6.literal("REPLACE"),
+      z5.strictObject({
+        kind: z5.literal("REPLACE"),
         lineId: IdSchema,
         variantId: IdSchema,
         quantity: qty
@@ -834,13 +811,13 @@ var CommerceProposalSchema = z6.strictObject({
     v.operations.flatMap((o) => o.kind === "REPLACE" ? [o.lineId] : [])
   )
 );
-var CommerceBasketSchema = z6.strictObject({
+var CommerceBasketSchema = z5.strictObject({
   basketId: IdSchema,
-  source: z6.enum(["RECOVERY_SNAPSHOT", "PROPOSED"]),
+  source: z5.enum(["RECOVERY_SNAPSHOT", "PROPOSED"]),
   observedAt: DateSchema,
   currency: CurrencySchema.nullable(),
-  lines: z6.array(
-    z6.strictObject({
+  lines: z5.array(
+    z5.strictObject({
       lineId: IdSchema,
       productId: IdSchema.nullable(),
       variantId: IdSchema.nullable(),
@@ -849,40 +826,100 @@ var CommerceBasketSchema = z6.strictObject({
     })
   ).max(100),
   fingerprint: HashSchema,
-  unknownFields: z6.array(z6.string().min(1).max(256)).max(128)
+  unknownFields: z5.array(z5.string().min(1).max(256)).max(128)
 }).refine((v) => distinct(v.lines.map((line) => line.lineId)));
-var CommerceProductSchema = z6.strictObject({
+var CommerceProductSaleEvidenceSchema = z5.strictObject({
+  regularPrice: MoneySchema.nullable(),
+  salePrice: MoneySchema.nullable(),
+  observedAt: DateSchema
+});
+var CommerceProductSchema = z5.strictObject({
   productId: IdSchema,
-  variantId: IdSchema,
-  title: z6.string().min(1).max(512),
-  url: z6.url({ protocol: /^https$/ }).refine((v) => {
+  variantId: IdSchema.nullable(),
+  title: z5.string().min(1).max(512),
+  url: z5.url({ protocol: /^https$/ }).refine((v) => {
     const u = new URL(v);
     return !u.username && !u.password && !u.port;
   }).nullable(),
-  available: z6.boolean().nullable(),
+  available: z5.boolean().nullable(),
   unitPrice: MoneySchema.nullable(),
   currency: CurrencySchema.nullable(),
-  productType: z6.string().max(512).nullable(),
-  vendor: z6.string().max(512).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(),
+  saleEvidence: CommerceProductSaleEvidenceSchema.nullable().optional(),
   observedAt: DateSchema
 });
-var CommerceOfferSchema = z6.strictObject({
+var CommerceOfferSchema = z5.strictObject({
   offerId: IdSchema,
-  title: z6.string().min(1).max(512),
-  method: z6.enum(["AUTOMATIC", "CODE"]),
-  code: z6.string().min(1).max(128).nullable(),
+  title: z5.string().min(1).max(512),
+  method: z5.enum(["AUTOMATIC", "CODE"]),
+  code: z5.string().min(1).max(128).nullable(),
   startsAt: DateSchema.nullable(),
   endsAt: DateSchema.nullable(),
-  support: z6.enum(["SUPPORTED", "UNSUPPORTED", "UNKNOWN"]),
-  reasonCodes: z6.array(z6.string().min(1).max(64)).max(16)
+  support: z5.enum(["SUPPORTED", "UNSUPPORTED", "UNKNOWN"]),
+  reasonCodes: z5.array(z5.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 condition = z6.strictObject({
-  code: z6.string().min(1).max(64),
-  description: z6.string().max(256)
+var CommerceDiscountConditionFactsSchema = z5.strictObject({
+  provider: z5.enum(["SHOPIFY", "WOOCOMMERCE"]),
+  completeness: z5.enum(["COMPLETE", "PARTIAL", "UNKNOWN"]),
+  observedAt: DateSchema,
+  providerStatus: z5.string().max(64),
+  unavailableAt: DateSchema.nullable(),
+  discountKind: z5.enum([
+    "PERCENTAGE",
+    "FIXED_AMOUNT",
+    "FREE_SHIPPING",
+    "BUY_X_GET_Y",
+    "OTHER",
+    "UNKNOWN"
+  ]),
+  discountValue: MoneySchema.nullable(),
+  discountCurrency: CurrencySchema.nullable(),
+  targeting: z5.strictObject({
+    kind: z5.enum([
+      "ALL",
+      "PRODUCTS",
+      "VARIANTS",
+      "CATEGORIES",
+      "COLLECTIONS",
+      "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)
+  }),
+  minimumSubtotal: MoneySchema.nullable(),
+  maximumSubtotal: MoneySchema.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(),
+  unrepresentedConditions: z5.array(z5.string().min(1).max(128)).max(24)
+});
+var CommerceDiscountDetailsSchema = z5.strictObject({
+  offer: CommerceOfferSchema,
+  facts: CommerceDiscountConditionFactsSchema
 });
-var CommerceEvidenceSchema = z6.strictObject({
+var condition = z5.strictObject({
+  code: z5.string().min(1).max(64),
+  description: z5.string().max(256)
+});
+var CommerceEvidenceSchema = z5.strictObject({
   evidenceId: HashSchema,
   turn: CommerceTurnIdentitySchema,
   grantId: IdSchema,
@@ -893,7 +930,7 @@ var CommerceEvidenceSchema = z6.strictObject({
   ruleFingerprint: HashSchema,
   evaluatedAt: DateSchema,
   expiresAt: DateSchema,
-  outcome: z6.enum([
+  outcome: z5.enum([
     "QUALIFIES_FOR_KNOWN_RULES",
     "DOES_NOT_QUALIFY",
     "UNKNOWN",
@@ -902,8 +939,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: z5.array(condition).max(32),
+  unresolvedConditions: z5.array(condition).max(32)
 }).superRefine((v, c) => {
   if (Date.parse(v.expiresAt) - Date.parse(v.evaluatedAt) > 6e4)
     c.addIssue({
@@ -913,16 +950,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 = z5.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: z5.array(z5.string().max(256)).max(3)
 }).refine((v) => v.product.available === true);
-var CommerceErrorCodeSchema = z6.enum([
+var CommerceErrorCodeSchema = z5.enum([
   "INVALID_INPUT",
   "DENIED",
   "STALE_TURN",
@@ -933,66 +970,81 @@ var CommerceErrorCodeSchema = z6.enum([
   "INCOMPATIBLE_VERSION"
 ]);
 function commerceToolResultSchema(data) {
-  return z6.union([
-    z6.strictObject({
+  return z5.union([
+    z5.strictObject({
       contractVersion: ContractVersionSchema,
-      status: z6.literal("OK"),
+      status: z5.literal("OK"),
       data,
-      renderedText: z6.string().max(4096)
+      renderedText: z5.string().max(4096)
     }),
-    z6.strictObject({
+    z5.strictObject({
       contractVersion: ContractVersionSchema,
-      status: z6.literal("ERROR"),
+      status: z5.literal("ERROR"),
       code: CommerceErrorCodeSchema,
-      retryable: z6.boolean(),
-      renderedText: z6.string().max(4096).optional()
+      retryable: z5.boolean(),
+      renderedText: z5.string().max(4096).optional()
     })
   ]);
 }
 var CommerceToolResultSchema = commerceToolResultSchema(
   boundedJson(262144)
 );
-var limit = z6.number().int().min(1).max(3).default(3);
+var limit = z5.number().int().min(1).max(3).default(3);
 var CommerceToolInputs = {
-  commerce_get_basket: z6.strictObject({}),
-  commerce_search_products: z6.strictObject({
-    query: z6.string().min(1).max(200),
+  commerce_get_basket: z5.strictObject({}),
+  commerce_search_products: z5.strictObject({
+    query: z5.string().min(1).max(200),
     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: z5.boolean().default(true),
+    limit: z5.number().int().min(1).max(20).default(10),
+    cursor: z5.string().max(2048).nullable().default(null)
+  }),
+  commerce_get_product: z5.strictObject({
+    productId: IdSchema,
+    variantId: IdSchema.nullable()
   }),
-  commerce_get_discount_options: z6.strictObject({}),
-  commerce_evaluate_discount: z6.strictObject({
+  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_details: z5.strictObject({ offerId: IdSchema }),
+  commerce_evaluate_discount: z5.strictObject({
     offerId: IdSchema,
     proposal: CommerceProposalSchema.nullable()
   }),
-  commerce_find_qualifying_products: z6.strictObject({
+  commerce_find_qualifying_products: z5.strictObject({
     offerId: IdSchema,
-    query: z6.string().min(1).max(200).nullable(),
+    query: z5.string().min(1).max(200).nullable(),
     limit
   }),
-  commerce_find_similar_products: z6.strictObject({
+  commerce_find_similar_products: z5.strictObject({
     variantId: IdSchema,
     offerId: IdSchema.nullable(),
     limit
   })
 };
-var alternatives = z6.strictObject({
-  alternatives: z6.array(CommerceAlternativeSchema).max(3),
-  truncated: z6.boolean()
+var alternatives = z5.strictObject({
+  alternatives: z5.array(CommerceAlternativeSchema).max(3),
+  truncated: z5.boolean()
 });
 var CommerceToolOutputs = {
   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: z5.strictObject({
+    products: z5.array(CommerceProductSchema).max(20),
+    cursor: z5.string().max(2048).nullable(),
+    truncated: z5.boolean()
+  }),
+  commerce_get_product: z5.strictObject({
+    product: CommerceProductSchema.nullable()
   }),
-  commerce_get_discount_options: z6.strictObject({
-    mode: z6.enum(["NONE", "FIXED", "AI_BEST_APPLICABLE"]),
-    offers: z6.array(CommerceOfferSchema).max(50),
-    truncated: z6.boolean()
+  commerce_get_discount_options: 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_details: z5.strictObject({
+    details: CommerceDiscountDetailsSchema.nullable()
   }),
   commerce_evaluate_discount: CommerceEvidenceSchema,
   commerce_find_qualifying_products: alternatives,
@@ -1015,16 +1067,6 @@ export {
   DetailsSchemaSchema,
   matchesSubset,
   compileSubset,
-  ContractVersionSchema,
-  IdSchema,
-  SemverSchema,
-  HashSchema,
-  DateSchema,
-  MoneySchema,
-  CurrencySchema,
-  LanguageSchema,
-  distinct,
-  boundedJson,
   ExternalQueryValueSchema,
   ExternalQueryMappingSchema,
   ExternalQueryMappingsSchema,
@@ -1078,8 +1120,11 @@ export {
   CommerceAssertionSchema,
   CommerceProposalSchema,
   CommerceBasketSchema,
+  CommerceProductSaleEvidenceSchema,
   CommerceProductSchema,
   CommerceOfferSchema,
+  CommerceDiscountConditionFactsSchema,
+  CommerceDiscountDetailsSchema,
   CommerceEvidenceSchema,
   CommerceAlternativeSchema,
   CommerceErrorCodeSchema,
@@ -1089,4 +1134,4 @@ export {
   CommerceToolOutputs,
   productBelongsToDomain
 };
-//# sourceMappingURL=chunk-QJNZJACH.js.map
+//# sourceMappingURL=chunk-XTKCNFLQ.js.map