@mablhq/mabl-cli 2.133.1 → 2.133.2

package/_bundled/@mablhq/test-model/validator/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/validator/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,KAAK,CAAC;AA0B7B,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAC;AAErD,MAAM,WAAW,eAAe;IAE9B,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAE1B,OAAO,EAAE,MAAM,CAAC;IAEhB,IAAI,EAAE,MAAM,CAAC;IAEb,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAEhC,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAE1B,OAAO,EAAE,MAAM,CAAC;IAEhB,IAAI,EAAE,MAAM,CAAC;IAEb,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAE/B,KAAK,EAAE,OAAO,CAAC;IAEf,MAAM,EAAE,eAAe,EAAE,CAAC;IAE1B,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED,wBAAgB,WAAW,IAAI,gBAAgB,CAE9C;AAED,wBAAgB,YAAY,CAAC,GAAG,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB,CAQ7E;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,QAAQ,EAAE,EAClB,UAAU,GAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAO,EACpC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,mBAAmB,GAAG,SAAS,GACjE,gBAAgB,CAiBlB;AA+GD,wBAAgB,WAAW,CACzB,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EACzB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,gBAAgB,CAgBlB;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EACzB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,gBAAgB,CAgBlB"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/validator/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,KAAK,CAAC;AAqC7B,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAC;AAErD,MAAM,WAAW,eAAe;IAE9B,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAE1B,OAAO,EAAE,MAAM,CAAC;IAEhB,IAAI,EAAE,MAAM,CAAC;IAEb,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAEhC,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAE1B,OAAO,EAAE,MAAM,CAAC;IAEhB,IAAI,EAAE,MAAM,CAAC;IAEb,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAE/B,KAAK,EAAE,OAAO,CAAC;IAEf,MAAM,EAAE,eAAe,EAAE,CAAC;IAE1B,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED,wBAAgB,WAAW,IAAI,gBAAgB,CAE9C;AAED,wBAAgB,YAAY,CAAC,GAAG,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB,CAQ7E;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,QAAQ,EAAE,EAClB,UAAU,GAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAO,EACpC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,mBAAmB,GAAG,SAAS,GACjE,gBAAgB,CAiBlB;AAuKD,wBAAgB,WAAW,CACzB,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EACzB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,gBAAgB,CAgBlB;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EACzB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,gBAAgB,CAgBlB"}

package/_bundled/@mablhq/test-model/validator/errors.js

@@ -13,6 +13,8 @@ const VARIANT_MATCH_CODES = new Set([
     'invalid_union',
     'custom',
 ]);
+const ZOD_DEFAULT_UNION_MESSAGE = 'Invalid input';
+const MAX_SUMMARIZED_VARIANTS = 4;
 function pathToJsonPath(path) {
     return path.filter((p) => typeof p !== 'symbol');
 }
@@ -60,6 +62,16 @@ function refineIssue(issue) {
         if (closest) {
             return closest;
         }
+        if (issue.message === ZOD_DEFAULT_UNION_MESSAGE) {
+            const variants = summarizeUnionVariants(issue);
+            if (variants) {
+                return {
+                    path: pathToJsonPath(issue.path),
+                    message: variants,
+                    code: `zod.${issue.code}`,
+                };
+            }
+        }
     }
     return {
         path: pathToJsonPath(issue.path),
@@ -94,6 +106,34 @@ function pickClosestVariantIssue(issue) {
         code: `zod.${deepest.code}`,
     };
 }
+function summarizeUnionVariants(issue) {
+    const variants = [];
+    for (const branchIssues of issue.errors) {
+        const fields = new Set();
+        for (const branchIssue of branchIssues) {
+            if (!VARIANT_MATCH_CODES.has(branchIssue.code))
+                continue;
+            const path = pathToJsonPath(branchIssue.path);
+            if (path.length === 0)
+                continue;
+            fields.add(path.join('.'));
+        }
+        if (fields.size > 0)
+            variants.push([...fields]);
+    }
+    const rendered = [
+        ...new Set(variants
+            .sort((a, b) => a.length - b.length)
+            .map((fields) => `(${fields.join(', ')})`)),
+    ];
+    if (rendered.length === 0)
+        return undefined;
+    const shown = rendered.slice(0, MAX_SUMMARIZED_VARIANTS);
+    const omitted = rendered.length - shown.length;
+    return (`No accepted shape matched. Satisfy the fields of one of them: ` +
+        `${shown.join(' or ')}` +
+        `${omitted > 0 ? ` (and ${omitted} other shapes)` : ''}.`);
+}
 function locateFindTargetUnionIssue(issue) {
     for (const branchIssues of issue.errors) {
         for (const branchIssue of branchIssues) {

package/_bundled/@mablhq/test-model/validator/schemas/condition-descriptor.d.ts

@@ -71,7 +71,7 @@ export declare const aiPromptConditionSchema: z.ZodObject<{
     metaPrompt: z.ZodOptional<z.ZodString>;
     criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
-export declare const conditionDescriptorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const conditionDescriptorSchema: z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
     conditionType: z.ZodLiteral<"comparison">;
     comparisonType: z.ZodEnum<{
         contains: "contains";
@@ -109,7 +109,7 @@ export declare const conditionDescriptorSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>]>;
 export type ConditionDescriptor = z.infer<typeof conditionDescriptorSchema>;
-export declare const conditionDescriptorAuthoringSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const conditionDescriptorAuthoringSchema: z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
     conditionType: z.ZodLiteral<"comparison">;
     comparisonType: z.ZodEnum<{
         contains: "contains";

package/_bundled/@mablhq/test-model/validator/schemas/condition-descriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"condition-descriptor.d.ts","sourceRoot":"","sources":["../../../src/validator/schemas/condition-descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAKtB,eAAO,MAAM,iBAAiB;;;;;EAK5B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;EAc7B,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;EAAqC,CAAC;AAI7E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;iBAcnC,CAAC;AAEJ,eAAO,MAAM,uBAAuB;;;;;;;iBAWmC,CAAC;AAiBxE,eAAO,MAAM,gCAAgC;;;;;;iBAE0B,CAAC;AASxE,eAAO,MAAM,qBAAqB;;iBAM/B,CAAC;AAEJ,eAAO,MAAM,uBAAuB;;;;;iBASmB,CAAC;AAKxD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBASnC,CAAC;AAEJ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAO5E,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAS5C,CAAC"}
+{"version":3,"file":"condition-descriptor.d.ts","sourceRoot":"","sources":["../../../src/validator/schemas/condition-descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAWtB,eAAO,MAAM,iBAAiB;;;;;EAK5B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;EAc7B,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;EAAqC,CAAC;AAI7E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;iBAcnC,CAAC;AAEJ,eAAO,MAAM,uBAAuB;;;;;;;iBAWmC,CAAC;AAiBxE,eAAO,MAAM,gCAAgC;;;;;;iBAE0B,CAAC;AASxE,eAAO,MAAM,qBAAqB;;iBAM/B,CAAC;AAEJ,eAAO,MAAM,uBAAuB;;;;;iBASmB,CAAC;AAKxD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBASrC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAO5E,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAS9C,CAAC"}

package/_bundled/@mablhq/test-model/validator/schemas/condition-descriptor.js

@@ -2,7 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.conditionDescriptorAuthoringSchema = exports.conditionDescriptorSchema = exports.aiPromptConditionSchema = exports.truthyConditionSchema = exports.presenceConditionAuthoringSchema = exports.presenceConditionSchema = exports.comparisonConditionSchema = exports.presenceEvaluationTypeEnum = exports.comparisonTypeEnum = exports.conditionTypeEnum = void 0;
 const zod_1 = require("zod");
+const described_union_1 = require("./described-union");
 const common_1 = require("./common");
+const CONDITION_DESCRIPTION = 'Condition to evaluate -- conditionType is one of comparison (with ' +
+    'comparisonType and comparatorValue), presence, truthy, or ai_prompt ' +
+    '(with userPrompt)';
 exports.conditionTypeEnum = zod_1.z.enum([
     'ai_prompt',
     'comparison',
@@ -66,19 +70,15 @@ exports.aiPromptConditionSchema = zod_1.z
     criteria: zod_1.z.array(zod_1.z.string()).optional(),
 })
     .describe('Use an AI prompt to evaluate a condition');
-exports.conditionDescriptorSchema = zod_1.z
-    .discriminatedUnion('conditionType', [
+exports.conditionDescriptorSchema = (0, described_union_1.describedDiscriminatedUnion)('conditionType', [
     exports.comparisonConditionSchema,
     exports.presenceConditionSchema,
     exports.truthyConditionSchema,
     exports.aiPromptConditionSchema,
-])
-    .describe('Condition to evaluate -- comparison, presence check, truthy check, or AI prompt');
-exports.conditionDescriptorAuthoringSchema = zod_1.z
-    .discriminatedUnion('conditionType', [
+], CONDITION_DESCRIPTION);
+exports.conditionDescriptorAuthoringSchema = (0, described_union_1.describedDiscriminatedUnion)('conditionType', [
     exports.comparisonConditionSchema,
     exports.presenceConditionAuthoringSchema,
     exports.truthyConditionSchema,
     exports.aiPromptConditionSchema,
-])
-    .describe('Condition to evaluate -- comparison, presence check, truthy check, or AI prompt');
+], CONDITION_DESCRIPTION);

package/_bundled/@mablhq/test-model/validator/schemas/described-union.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { $ZodTypeDiscriminable } from 'zod/v4/core';
+export declare function describedUnion<const T extends readonly [z.ZodType, ...z.ZodType[]]>(options: T, description: string): z.ZodUnion<T>;
+export declare function describedDiscriminatedUnion<const T extends readonly [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]]>(discriminator: string, options: T, description: string): z.ZodDiscriminatedUnion<T>;
+//# sourceMappingURL=described-union.d.ts.map

package/_bundled/@mablhq/test-model/validator/schemas/described-union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"described-union.d.ts","sourceRoot":"","sources":["../../../src/validator/schemas/described-union.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AACtB,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,aAAa,CAAC;AAgBvD,wBAAgB,cAAc,CAC5B,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC,EACpD,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,MAAM,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAEhD;AAQD,wBAAgB,2BAA2B,CACzC,KAAK,CAAC,CAAC,SAAS,SAAS,CAAC,qBAAqB,EAAE,GAAG,qBAAqB,EAAE,CAAC,EAE5E,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,CAAC,EACV,WAAW,EAAE,MAAM,GAClB,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAI5B"}

package/_bundled/@mablhq/test-model/validator/schemas/described-union.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describedUnion = describedUnion;
+exports.describedDiscriminatedUnion = describedDiscriminatedUnion;
+const zod_1 = require("zod");
+function describedUnion(options, description) {
+    return zod_1.z.union(options, { error: () => description }).describe(description);
+}
+function describedDiscriminatedUnion(discriminator, options, description) {
+    return zod_1.z
+        .discriminatedUnion(discriminator, options, { error: () => description })
+        .describe(description);
+}

package/_bundled/@mablhq/test-model/validator/schemas/extract-descriptor.d.ts

@@ -6,7 +6,7 @@ export declare const extractTypeEnum: z.ZodEnum<{
     extract_inner_text: "extract_inner_text";
     extract_prompt: "extract_prompt";
 }>;
-export declare const extractDescriptorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const extractDescriptorSchema: z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
     extractType: z.ZodLiteral<"extract_attribute">;
     attributeName: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{

package/_bundled/@mablhq/test-model/validator/schemas/extract-descriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extract-descriptor.d.ts","sourceRoot":"","sources":["../../../src/validator/schemas/extract-descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,eAAe;;;;;;EAM1B,CAAC;AAkCH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;mBAQwB,CAAC;AAE7D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}
+{"version":3,"file":"extract-descriptor.d.ts","sourceRoot":"","sources":["../../../src/validator/schemas/extract-descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,eAAO,MAAM,eAAe;;;;;;EAM1B,CAAC;AAkCH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;mBAanC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/_bundled/@mablhq/test-model/validator/schemas/extract-descriptor.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractDescriptorSchema = exports.extractTypeEnum = void 0;
 const zod_1 = require("zod");
+const described_union_1 = require("./described-union");
 exports.extractTypeEnum = zod_1.z.enum([
     'extract_attribute',
     'extract_css_properties',
@@ -33,12 +34,13 @@ const extractInnerTextSchema = zod_1.z.object({
 const extractPromptSchema = zod_1.z.object({
     extractType: zod_1.z.literal('extract_prompt'),
 });
-exports.extractDescriptorSchema = zod_1.z
-    .discriminatedUnion('extractType', [
+exports.extractDescriptorSchema = (0, described_union_1.describedDiscriminatedUnion)('extractType', [
     extractAttributeSchema,
     extractCssPropertiesSchema,
     extractEmailAttributeSchema,
     extractInnerTextSchema,
     extractPromptSchema,
-])
-    .describe('What value to extract from the target element');
+], 'What value to extract from the target element — extractType is one of ' +
+    'extract_attribute or extract_css_properties (each with attributeName), ' +
+    'extract_email_attribute (with attributeName), extract_inner_text, or ' +
+    'extract_prompt.');

package/_bundled/@mablhq/test-model/validator/schemas/find-descriptors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find-descriptors.d.ts","sourceRoot":"","sources":["../../../src/validator/schemas/find-descriptors.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"find-descriptors.d.ts","sourceRoot":"","sources":["../../../src/validator/schemas/find-descriptors.ts"],"names":[],"mappings":"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"}

package/_bundled/@mablhq/test-model/validator/schemas/find-descriptors.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mobileFindDescriptorSchema = exports.webViewFindElementDescriptorSchema = exports.mobileFindCustomDescriptorSchema = exports.mobileFindElementDescriptorSchema = exports.findDescriptorSchema = exports.findTabDescriptorSchema = exports.findEmailDescriptorSchema = exports.findCookieDescriptorSchema = exports.browserFindAuthoringSchema = exports.findCustomDescriptorSchema = exports.findElementDescriptorSchema = exports.browserFindDescriptorSchema = exports.browserFindTargetSchema = exports.cookieSelectorSchema = exports.mobileFindSpecificationSchema = exports.mobileElementSelectorSchema = exports.normalizedFindDescriptorSchema = exports.mobileFindOptionsSchema = exports.findOptionsSchema = exports.customCssSelectorSchema = exports.customXpathSelectorSchema = exports.simpleElementSelectorSchema = exports.primaryFindMethodEnum = exports.propertyComparatorEnum = exports.elementExpectationEnum = exports.confidenceLevelEnum = exports.customFindTypeEnum = exports.findTypeEnum = void 0;
 const zod_1 = require("zod");
 const mablscriptFind_1 = require("../../mablscriptFind");
+const described_union_1 = require("./described-union");
 exports.findTypeEnum = zod_1.z.enum([
     'find_all',
     'find_any',
@@ -393,8 +394,7 @@ const authoringFindOptionsSchema = zod_1.z
 })
     .optional()
     .describe('Optional timeout for this find');
-exports.browserFindAuthoringSchema = zod_1.z
-    .union([
+exports.browserFindAuthoringSchema = (0, described_union_1.describedUnion)([
     zod_1.z
         .object({
         find_uuid: zod_1.z
@@ -415,8 +415,9 @@ exports.browserFindAuthoringSchema = zod_1.z
         findOptions: authoringFindOptionsSchema,
     })
         .describe('Author a new find with a visual description (required) and an optional Playwright locator'),
-])
-    .describe('Element find: either reuse a known find by uuid, or author a new one (a required visual description, plus an optional locator).');
+], 'Element find — either {find_uuid} to reuse a find the session already knows, ' +
+    'or {visual_description, locator?} to author a new one (the visual ' +
+    'description is required).');
 exports.findCookieDescriptorSchema = zod_1.z
     .object({
     findType: zod_1.z.literal('find_cookie'),
@@ -441,19 +442,23 @@ const tabSelectorSchema = zod_1.z
     .refine((tab) => tab.url !== undefined || tab.title !== undefined, {
     message: 'A tab selector must identify the tab by at least one of url or title.',
 });
-const findTabTargetSchema = zod_1.z.union([zod_1.z.literal('initial'), tabSelectorSchema]);
+const findTabTargetSchema = (0, described_union_1.describedUnion)([zod_1.z.literal('initial'), tabSelectorSchema], 'Tab to find — either the string "initial" for the tab the test started in, ' +
+    'or {selector_type: "tab"} with at least one of url or title.');
 exports.findTabDescriptorSchema = zod_1.z
     .object({
     findType: zod_1.z.literal('find_tab'),
     findTarget: findTabTargetSchema,
 })
     .passthrough();
-exports.findDescriptorSchema = zod_1.z.union([
+exports.findDescriptorSchema = (0, described_union_1.describedUnion)([
     exports.findCookieDescriptorSchema,
     exports.findEmailDescriptorSchema,
     exports.findTabDescriptorSchema,
     exports.browserFindDescriptorSchema,
-]);
+], 'Browser find — {findType, findTarget}, where findTarget follows findType: ' +
+    'find_one / find_first / find_last / find_all take an element selector, ' +
+    'find_cookie a cookie selector, find_tab a tab selector, find_email an ' +
+    'email selector.');
 exports.mobileFindElementDescriptorSchema = zod_1.z
     .object({
     findType: zod_1.z.literal('find_one'),
@@ -486,8 +491,11 @@ exports.webViewFindElementDescriptorSchema = exports.mobileFindElementDescriptor
         url: zod_1.z.string(),
     }),
 });
-exports.mobileFindDescriptorSchema = zod_1.z.union([
+exports.mobileFindDescriptorSchema = (0, described_union_1.describedUnion)([
     exports.webViewFindElementDescriptorSchema,
     exports.mobileFindElementDescriptorSchema,
     exports.mobileFindCustomDescriptorSchema,
-]);
+], 'Mobile find — {findType: "find_one", findTarget} for a native element, the ' +
+    'same plus {webView: {descriptor, title, url}} for an element inside a web ' +
+    'view, or {findType: find_first|find_last|find_all, findTarget} with an ' +
+    'xpath selector.');

package/_bundled/@mablhq/test-model/validator/schemas/steps/assertions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../../../../src/validator/schemas/steps/assertions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAgFtB,eAAO,MAAM,0BAA0B,EAAE,CAAC,CAAC,OA+BxC,CAAC;AAMJ,eAAO,MAAM,sBAAsB,EAAE,CAAC,CAAC,OAGpC,CAAC;AACJ,eAAO,MAAM,0BAA0B,EAAE,CAAC,CAAC,OAGxC,CAAC;AA8GJ,eAAO,MAAM,mCAAmC,EAAE,CAAC,CAAC,OAOjD,CAAC;AAEJ,eAAO,MAAM,+BAA+B,EAAE,CAAC,CAAC,OAG7C,CAAC;AACJ,eAAO,MAAM,mCAAmC,EAAE,CAAC,CAAC,OAGjD,CAAC;AAGJ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;iBAE2B,CAAC;AAGjE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;iBAEqB,CAAC;AAY1D,eAAO,MAAM,6BAA6B,EAAE,CAAC,CAAC,OACe,CAAC;AAE9D,eAAO,MAAM,sCAAsC,EAAE,CAAC,CAAC,OACe,CAAC"}
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../../../../src/validator/schemas/steps/assertions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AA2FtB,eAAO,MAAM,0BAA0B,EAAE,CAAC,CAAC,OA+BxC,CAAC;AAMJ,eAAO,MAAM,sBAAsB,EAAE,CAAC,CAAC,OAGpC,CAAC;AACJ,eAAO,MAAM,0BAA0B,EAAE,CAAC,CAAC,OAGxC,CAAC;AAqHJ,eAAO,MAAM,mCAAmC,EAAE,CAAC,CAAC,OAOjD,CAAC;AAEJ,eAAO,MAAM,+BAA+B,EAAE,CAAC,CAAC,OAG7C,CAAC;AACJ,eAAO,MAAM,mCAAmC,EAAE,CAAC,CAAC,OAGjD,CAAC;AAGJ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;iBAE2B,CAAC;AAGjE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;iBAEqB,CAAC;AAY1D,eAAO,MAAM,6BAA6B,EAAE,CAAC,CAAC,OACe,CAAC;AAE9D,eAAO,MAAM,sCAAsC,EAAE,CAAC,CAAC,OACe,CAAC"}

package/_bundled/@mablhq/test-model/validator/schemas/steps/assertions.js

@@ -8,6 +8,7 @@ const extract_descriptor_1 = require("../extract-descriptor");
 const count_descriptor_1 = require("../count-descriptor");
 const find_descriptors_1 = require("../find-descriptors");
 const shared_1 = require("./shared");
+const described_union_1 = require("../described-union");
 const GetCurrentLocationDescriptor_1 = require("../../../types/GetCurrentLocationDescriptor");
 const URL_PROPERTY_LIST = GetCurrentLocationDescriptor_1.LOCATION_URL_PROPERTIES.join(', ');
 const EXTRACT_DESCRIPTION = 'Extract a specific value from the target before asserting. For a ' +
@@ -37,14 +38,17 @@ const javaScriptTargetSchema = zod_1.z
     javaScript: shared_1.javaScriptDescriptorSchema,
 })
     .passthrough();
-const assertTargetSchema = zod_1.z.union([
+const ASSERT_TARGET_SHAPES = '{kind: "Location"} for the current URL, {kind: "GetVariable", variable} ' +
+    'for a variable, {kind: "Viewport"} for the whole page, {javaScript: ...} ' +
+    'for a JS expression, or a find descriptor for an element';
+const assertTargetSchema = (0, described_union_1.describedUnion)([
     getCurrentLocationTargetSchema,
     getVariableTargetSchema,
     getViewportTargetSchema,
     javaScriptTargetSchema,
     find_descriptors_1.findDescriptorSchema,
     find_descriptors_1.mobileFindDescriptorSchema,
-]);
+], `Assert target — one of: ${ASSERT_TARGET_SHAPES}.`);
 exports.assertStepDescriptorSchema = common_1.baseStepDescriptorSchema
     .extend({
     target: assertTargetSchema
@@ -69,19 +73,20 @@ exports.assertStepDescriptorSchema = common_1.baseStepDescriptorSchema
     .describe('Assert a condition on a target (element, variable, URL, or JS expression)');
 exports.ifStepDescriptorSchema = exports.assertStepDescriptorSchema.describe('Conditional branch -- evaluates a condition to decide which steps to execute');
 exports.elseIfStepDescriptorSchema = exports.assertStepDescriptorSchema.describe('Additional conditional branch within an If block');
-const assertTargetAuthoringSchema = zod_1.z.union([
+const assertTargetAuthoringSchema = (0, described_union_1.describedUnion)([
     getCurrentLocationTargetSchema,
     getVariableTargetSchema,
     getViewportTargetSchema,
     javaScriptTargetSchema,
     find_descriptors_1.browserFindAuthoringSchema,
-]);
-const nonLocationAssertTargetAuthoringSchema = zod_1.z.union([
+], `Assert target — one of: ${ASSERT_TARGET_SHAPES}.`);
+const nonLocationAssertTargetAuthoringSchema = (0, described_union_1.describedUnion)([
     getVariableTargetSchema,
     getViewportTargetSchema,
     javaScriptTargetSchema,
     find_descriptors_1.browserFindAuthoringSchema,
-]);
+], `Assert target — one of: ${ASSERT_TARGET_SHAPES}. Comparing the current ` +
+    'URL needs an extract naming the URL property.');
 const locationExtractAuthoringSchema = zod_1.z
     .object({
     extractType: zod_1.z.literal('extract_attribute'),

package/_bundled/@mablhq/test-model/validator/schemas/steps/files-downloads.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"files-downloads.d.ts","sourceRoot":"","sources":["../../../../src/validator/schemas/steps/files-downloads.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AA2BtB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI4B,CAAC;AAkF5D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAamB,CAAC;AAG5D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;iBAEqB,CAAC;AA0BzD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4C6C,CAAC"}
+{"version":3,"file":"files-downloads.d.ts","sourceRoot":"","sources":["../../../../src/validator/schemas/steps/files-downloads.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AA4BtB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI4B,CAAC;AAmF5D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAamB,CAAC;AAG5D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;iBAEqB,CAAC;AA0BzD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4C6C,CAAC"}

package/_bundled/@mablhq/test-model/validator/schemas/steps/files-downloads.js

@@ -6,6 +6,7 @@ const common_1 = require("../common");
 const find_descriptors_1 = require("../find-descriptors");
 const shared_1 = require("./shared");
 const mablscriptFind_1 = require("../../../mablscriptFind");
+const described_union_1 = require("../described-union");
 const nonBlankSourceId = () => zod_1.z.string().trim().min(1).regex(/\S/);
 const fileUploadDescriptorSchema = zod_1.z.object({
     id: zod_1.z.string().optional(),
@@ -58,10 +59,8 @@ const runVariableFileDescriptor = zod_1.z
         'display/error metadata only).'),
 })
     .strict();
-const fileUploadDescriptorAuthoringSchema = zod_1.z.union([
-    workspaceFileDescriptor,
-    runVariableFileDescriptor,
-]);
+const fileUploadDescriptorAuthoringSchema = (0, described_union_1.describedUnion)([workspaceFileDescriptor, runVariableFileDescriptor], 'File to upload — exactly one source: {id} for a workspace file upload, or ' +
+    '{file_variable_ref} for a run file-variable.');
 exports.setFilesStepAuthoringSchema = shared_1.stepWithBrowserFindAuthoringSchema
     .extend({
     find: find_descriptors_1.browserFindAuthoringSchema.describe('Required. The file input element to set files on.'),

package/_bundled/@mablhq/test-model/validator/schemas/steps/meta-steps.d.ts

@@ -64,7 +64,7 @@ export declare const evaluateFlowStepSchema: z.ZodObject<{
             iteration_value: z.ZodOptional<z.ZodString>;
             iteration_condition: z.ZodOptional<z.ZodObject<{
                 If: z.ZodIntersection<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodObject<{
-                    condition: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    condition: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
                         conditionType: z.ZodLiteral<"comparison">;
                         comparisonType: z.ZodEnum<{
                             contains: "contains";

package/_bundled/@mablhq/test-model/validator/schemas/steps/shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/validator/schemas/steps/shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAmBtB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMtB,CAAC;AAWjB,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI/B,CAAC;AAOjB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAM7D;AAQD,eAAO,MAAM,gCAAgC,EAAE,WAAW,CAAC,MAAM,CAW/D,CAAC;AAKH,eAAO,MAAM,aAAa;;;;EAIvB,CAAC;AA8DJ,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBASpC,CAAC;AAQJ,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;mBAE6B,CAAC;AAM9E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;mBAGlC,CAAC;AAKH,eAAO,MAAM,kBAAkB;;;mBAAgD,CAAC;AAKhF,eAAO,MAAM,cAAc;;;;iBAQ+B,CAAC"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/validator/schemas/steps/shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAoBtB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMtB,CAAC;AAWjB,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI/B,CAAC;AAOjB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAM7D;AAQD,eAAO,MAAM,gCAAgC,EAAE,WAAW,CAAC,MAAM,CAW/D,CAAC;AAKH,eAAO,MAAM,aAAa;;;;EAIvB,CAAC;AAyEJ,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAQtC,CAAC;AAQF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;mBAG/C,CAAC;AAMF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;mBAGnC,CAAC;AAKF,eAAO,MAAM,kBAAkB;;;mBAAgD,CAAC;AAKhF,eAAO,MAAM,cAAc;;;;iBAQ+B,CAAC"}

package/_bundled/@mablhq/test-model/validator/schemas/steps/shared.js

@@ -5,6 +5,7 @@ exports.hasBrowserFindLocator = hasBrowserFindLocator;
 const zod_1 = require("zod");
 const common_1 = require("../common");
 const find_descriptors_1 = require("../find-descriptors");
+const described_union_1 = require("../described-union");
 exports.stepWithBrowserFindSchema = common_1.baseStepDescriptorSchema
     .extend({
     find: find_descriptors_1.browserFindDescriptorSchema.optional(),
@@ -39,6 +40,8 @@ exports.BROWSER_FIND_REQUIRED_STEP_TYPES = new Set([
 exports.onFailureEnum = zod_1.z
     .enum(['continue', 'terminate', 'failAtEnd'])
     .describe('Behavior when a step fails: continue = pass with warning, terminate = fail immediately, failAtEnd = continue executing but mark test failed at the end');
+const INLINE_SNIPPET_SHAPE = 'inline code {inlineSnippet: {body, parameters: []}, parameterOverrides: []}';
+const REUSABLE_SNIPPET_SHAPE = 'reusable snippet {snippetId, snippetInvariantId, parameterOverrides: []}';
 const parameterOverrideSchema = zod_1.z.object({
     id: zod_1.z.string(),
     value: zod_1.z.string(),
@@ -82,21 +85,14 @@ const legacyInlineJavaScriptSchema = zod_1.z.object({
     encodedJS: zod_1.z.string(),
     actionCode: zod_1.z.string().optional(),
 });
-exports.javaScriptDescriptorSchema = zod_1.z
-    .union([
+exports.javaScriptDescriptorSchema = (0, described_union_1.describedUnion)([
     reusableSnippetSchema,
     inlineSnippetSchema,
     legacyReusableSnippetSchema,
     legacyInlineJavaScriptSchema,
-])
-    .describe('JavaScript code reference — inline snippet, reusable snippet, or legacy encoded JS');
-exports.javaScriptDescriptorAuthoringSchema = zod_1.z
-    .union([reusableSnippetSchema, inlineSnippetSchema])
-    .describe('JavaScript code reference — inline snippet or reusable snippet');
-exports.snippetDescriptorSchema = zod_1.z.union([
-    reusableSnippetSchema,
-    inlineSnippetSchema,
-]);
+], `JavaScript code reference — one of: ${INLINE_SNIPPET_SHAPE}; ${REUSABLE_SNIPPET_SHAPE}; or legacy {encodedJS}.`);
+exports.javaScriptDescriptorAuthoringSchema = (0, described_union_1.describedUnion)([reusableSnippetSchema, inlineSnippetSchema], `JavaScript code reference — one of: ${INLINE_SNIPPET_SHAPE}; or ${REUSABLE_SNIPPET_SHAPE}.`);
+exports.snippetDescriptorSchema = (0, described_union_1.describedUnion)([reusableSnippetSchema, inlineSnippetSchema], `Snippet — one of: ${INLINE_SNIPPET_SHAPE}; or ${REUSABLE_SNIPPET_SHAPE}.`);
 exports.textOrSymbolSchema = zod_1.z.union([zod_1.z.string(), common_1.mablSymbolObjectSchema]);
 exports.aiPromptSchema = zod_1.z
     .object({

package/_bundled/@mablhq/test-model/validator/schemas/steps/variables-js.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"variables-js.d.ts","sourceRoot":"","sources":["../../../../src/validator/schemas/steps/variables-js.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AA8FtB,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,OAatC,CAAC;AAGJ,eAAO,MAAM,8BAA8B,EAAE,CAAC,CAAC,OAG5C,CAAC;AAGJ,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKyB,CAAC;AAQnE,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKgB,CAAC;AAGnE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;iBAKkB,CAAC"}
+{"version":3,"file":"variables-js.d.ts","sourceRoot":"","sources":["../../../../src/validator/schemas/steps/variables-js.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AA4GtB,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,OAatC,CAAC;AAGJ,eAAO,MAAM,8BAA8B,EAAE,CAAC,CAAC,OAG5C,CAAC;AAGJ,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKyB,CAAC;AAQnE,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKgB,CAAC;AAGnE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;iBAKkB,CAAC"}

package/_bundled/@mablhq/test-model/validator/schemas/steps/variables-js.js

@@ -5,6 +5,7 @@ const zod_1 = require("zod");
 const common_1 = require("../common");
 const find_descriptors_1 = require("../find-descriptors");
 const shared_1 = require("./shared");
+const described_union_1 = require("../described-union");
 const emailGeneratorSchema = zod_1.z.object({
     type: zod_1.z.literal('EMAIL'),
 });
@@ -34,7 +35,7 @@ const fileContentsGeneratorSchema = zod_1.z.object({
     type: zod_1.z.literal('FILE_CONTENTS'),
     file_variable_ref: zod_1.z.string().min(1),
 });
-const urlGeneratorSchema = zod_1.z.discriminatedUnion('urlPart', [
+const urlGeneratorSchema = (0, described_union_1.describedDiscriminatedUnion)('urlPart', [
     zod_1.z.object({
         type: zod_1.z.literal('URL'),
         urlPart: zod_1.z.literal('full'),
@@ -62,8 +63,10 @@ const urlGeneratorSchema = zod_1.z.discriminatedUnion('urlPart', [
         urlPart: zod_1.z.literal('regex'),
         regexPattern: zod_1.z.string().min(1),
     }),
-]);
-const generatorSchema = zod_1.z.discriminatedUnion('type', [
+], 'URL generator — urlPart is one of full, hostname, hash, pathSegment (with ' +
+    'pathSegmentIndex), queryParameter (with queryParameterName), or regex ' +
+    '(with regexPattern).');
+const generatorSchema = (0, described_union_1.describedDiscriminatedUnion)('type', [
     emailGeneratorSchema,
     patternGeneratorSchema,
     javaScriptGeneratorSchema,
@@ -72,7 +75,10 @@ const generatorSchema = zod_1.z.discriminatedUnion('type', [
     cookieValueGeneratorSchema,
     fileContentsGeneratorSchema,
     urlGeneratorSchema,
-]);
+], 'How to generate the variable value — type is one of EMAIL, PATTERN (with ' +
+    'pattern), JAVASCRIPT (with javaScript), ATTRIBUTE (with attribute), ' +
+    'ELEMENT_COUNT, COOKIE_ATTRIBUTE (with cookieSelector and attribute), ' +
+    'FILE_CONTENTS (with file_variable_ref), or URL (with urlPart).');
 exports.createVariableStepSchema = common_1.baseStepDescriptorSchema
     .extend({
     name: zod_1.z

package/_bundled/@mablhq-internal/mobile-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mablhq-internal/mobile-runtime",
-  "version": "2.133.1",
+  "version": "2.133.2",
   "main": "./index.js",
   "types": "./index.d.ts"
 }