@midscene/shared 1.12.7-beta-20260914023554.0 → 1.12.7

package/dist/es/cli/cli-args.mjs

@@ -1,15 +1,8 @@
 import { z } from "zod";
 import { getKeyAliases } from "../key-alias-utils.mjs";
-import { getZodValueKinds } from "../zod-schema-utils.mjs";
 import { CLIError } from "./cli-error.mjs";
-const cliNumberPattern = /^-?\d+(\.\d+)?$/;
-function parseValue(raw) {
-    const parsedJson = parseJsonValue(raw);
-    if (parsedJson !== raw) return parsedJson;
-    if (cliNumberPattern.test(raw)) return Number(raw);
-    return raw;
-}
-function walkCliArgs(args, setArgValue, fieldByCliName) {
+import { parseCliValue, parseValue } from "./cli-value.mjs";
+function walkCliArgs(args, setArgValue) {
     for(let i = 0; i < args.length; i++){
         const arg = args[i];
         if (!arg.startsWith('--')) continue;
@@ -17,10 +10,10 @@ function walkCliArgs(args, setArgValue, fieldByCliName) {
         const eqIdx = body.indexOf('=');
         if (eqIdx >= 0) {
             const key = body.slice(0, eqIdx);
-            setArgValue(key, parseCliValue(body.slice(eqIdx + 1), fieldByCliName?.get(key)));
+            setArgValue(key, body.slice(eqIdx + 1));
         } else if (args[i + 1] && !args[i + 1].startsWith('--')) {
             i++;
-            setArgValue(body, parseCliValue(args[i], fieldByCliName?.get(body)));
+            setArgValue(body, args[i]);
         } else setArgValue(body, true);
     }
 }
@@ -29,48 +22,29 @@ function buildCliFieldIndex(def) {
     for (const [schemaKey, field] of Object.entries(def.schema))for (const cliName of getAcceptedCliOptionNames(schemaKey, def.cli?.options?.[schemaKey]))fieldByCliName.set(cliName, field);
     return fieldByCliName;
 }
-function parseJsonValue(raw) {
-    if (!raw.startsWith('{') && !raw.startsWith('[')) return raw;
-    try {
-        return JSON.parse(raw);
-    } catch  {
-        return raw;
-    }
-}
-function parseCliValue(raw, field) {
-    if (!field) return parseValue(raw);
-    const kinds = getZodValueKinds(field);
-    if (kinds.has('object') || kinds.has('array')) {
-        const parsedJson = parseJsonValue(raw);
-        if (parsedJson !== raw) return parsedJson;
-    }
-    if (kinds.has('string')) return raw;
-    if (kinds.has('number') && cliNumberPattern.test(raw)) return Number(raw);
-    if (kinds.has('boolean')) {
-        if ('true' === raw) return true;
-        if ('false' === raw) return false;
-    }
-    return kinds.has('unknown') ? parseValue(raw) : raw;
-}
 function parseCliArgs(args, def) {
-    const result = {};
     const fieldByCliName = def ? buildCliFieldIndex(def) : void 0;
-    walkCliArgs(args, (key, value)=>{
-        const existing = result[key];
-        if (void 0 === existing) {
-            result[key] = value;
-            return;
-        }
-        if (Array.isArray(existing)) {
-            existing.push(value);
-            result[key] = existing;
-            return;
+    const tokensByName = new Map();
+    walkCliArgs(args, (key, raw)=>{
+        const tokens = tokensByName.get(key) ?? [];
+        tokens.push(raw);
+        tokensByName.set(key, tokens);
+    });
+    const result = {};
+    for (const [key, tokens] of tokensByName){
+        let elementIndex = 0;
+        for (const raw of tokens){
+            const existing = result[key];
+            const value = true === raw ? true : parseCliValue(raw, fieldByCliName?.get(key), tokens.length > 1 ? elementIndex : void 0);
+            if (void 0 === existing) result[key] = value;
+            else if (Array.isArray(existing)) existing.push(value);
+            else result[key] = [
+                existing,
+                value
+            ];
+            elementIndex = Array.isArray(result[key]) ? result[key].length : 1;
         }
-        result[key] = [
-            existing,
-            value
-        ];
-    }, fieldByCliName);
+    }
     return result;
 }
 function formatCliOptionName(name) {

package/dist/es/cli/cli-value.mjs

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { unwrapZodField } from "../zod-schema-utils.mjs";
+const cliNumberPattern = /^-?\d+(\.\d+)?$/;
+function getFieldDef(field) {
+    return field._def;
+}
+function getFieldKind(field) {
+    return getFieldDef(field).typeName;
+}
+function parseJsonValue(raw) {
+    if (!raw.startsWith('{') && !raw.startsWith('[')) return raw;
+    try {
+        return JSON.parse(raw);
+    } catch  {
+        return raw;
+    }
+}
+function parseValue(raw) {
+    const parsed = parseJsonValue(raw);
+    if (parsed !== raw) return parsed;
+    return cliNumberPattern.test(raw) ? Number(raw) : raw;
+}
+function getInputFields(field) {
+    const input = unwrapZodField(field);
+    const inputDef = getFieldDef(input);
+    if (inputDef.typeName === z.ZodFirstPartyTypeKind.ZodUnion) return (inputDef.options ?? []).flatMap(getInputFields);
+    return [
+        input
+    ];
+}
+function getRepeatedInputFields(fields, index) {
+    const collections = fields.filter((field)=>{
+        const kind = getFieldKind(field);
+        return kind === z.ZodFirstPartyTypeKind.ZodArray || kind === z.ZodFirstPartyTypeKind.ZodTuple;
+    });
+    if (0 === collections.length) return fields;
+    return collections.flatMap((field)=>{
+        const fieldDef = getFieldDef(field);
+        const item = fieldDef.typeName === z.ZodFirstPartyTypeKind.ZodArray ? fieldDef.type : fieldDef.items?.[index] ?? fieldDef.rest;
+        return item ? getInputFields(item) : [];
+    });
+}
+function acceptsValue(field, value) {
+    switch(getFieldKind(field)){
+        case z.ZodFirstPartyTypeKind.ZodString:
+            return 'string' == typeof value && field.safeParse(value).success;
+        case z.ZodFirstPartyTypeKind.ZodNumber:
+            return 'number' == typeof value && field.safeParse(value).success;
+        case z.ZodFirstPartyTypeKind.ZodBoolean:
+            return 'boolean' == typeof value;
+        case z.ZodFirstPartyTypeKind.ZodEnum:
+        case z.ZodFirstPartyTypeKind.ZodNativeEnum:
+        case z.ZodFirstPartyTypeKind.ZodLiteral:
+            return field.safeParse(value).success;
+        case z.ZodFirstPartyTypeKind.ZodArray:
+        case z.ZodFirstPartyTypeKind.ZodTuple:
+            return Array.isArray(value);
+        case z.ZodFirstPartyTypeKind.ZodObject:
+        case z.ZodFirstPartyTypeKind.ZodRecord:
+        case z.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+            return 'object' == typeof value && null !== value && !Array.isArray(value);
+        default:
+            return;
+    }
+}
+function usesLegacyInference(field) {
+    const kind = getFieldKind(field);
+    return kind === z.ZodFirstPartyTypeKind.ZodAny || kind === z.ZodFirstPartyTypeKind.ZodUnknown;
+}
+function parseCliValue(raw, field, index) {
+    if (!field) return parseValue(raw);
+    const json = parseJsonValue(raw);
+    const wholeFields = getInputFields(field);
+    if (json !== raw && wholeFields.some((input)=>acceptsValue(input, json))) return json;
+    const fields = void 0 === index ? wholeFields : getRepeatedInputFields(wholeFields, index);
+    const candidates = json !== raw ? [
+        json,
+        raw
+    ] : [
+        raw
+    ];
+    if (cliNumberPattern.test(raw)) candidates.push(Number(raw));
+    if ('true' === raw || 'false' === raw) candidates.push('true' === raw);
+    for (const candidate of candidates)if (fields.some((input)=>acceptsValue(input, candidate))) return candidate;
+    return fields.some(usesLegacyInference) ? parseValue(raw) : raw;
+}
+export { parseCliValue, parseValue };

package/dist/es/env/parse-model-config.mjs

@@ -5,7 +5,7 @@ import { assert } from "../utils.mjs";
 import { maskConfig, parseJson } from "./helper.mjs";
 import { initDebugConfig } from "./init-debug.mjs";
 const MODEL_CONFIG_DOC_URL = 'https://midscenejs.com/model-common-config.html';
-const getCurrentVersion = ()=>"1.12.7-beta-20260914023554.0";
+const getCurrentVersion = ()=>"1.12.7";
 const getInvalidModelFamilyMessage = (modelFamily)=>`Invalid MIDSCENE_MODEL_FAMILY value: ${modelFamily}. Current version v${getCurrentVersion()} accepts the following model families: ${MODEL_FAMILY_VALUES.join(', ')}. You can also visit ${MODEL_CONFIG_DOC_URL} for the latest configuration information.`;
 const KEYS_MAP = {
     insight: INSIGHT_MODEL_CONFIG_KEYS,

package/dist/es/zod-schema-utils.mjs

@@ -1,4 +1,3 @@
-import { z } from "zod";
 function unwrapZodField(field) {
     const f = field;
     if (!f._def) return f;
@@ -9,56 +8,6 @@ function unwrapZodField(field) {
     }
     return f;
 }
-function getLiteralValueKind(value) {
-    if ('string' == typeof value) return 'string';
-    if ('number' == typeof value) return 'number';
-    if ('boolean' == typeof value) return 'boolean';
-    return 'unknown';
-}
-function getZodValueKinds(field) {
-    const actualField = unwrapZodField(field);
-    const definition = actualField._def;
-    switch(definition?.typeName){
-        case 'ZodString':
-        case 'ZodEnum':
-            return new Set([
-                'string'
-            ]);
-        case 'ZodNumber':
-            return new Set([
-                'number'
-            ]);
-        case 'ZodBoolean':
-            return new Set([
-                'boolean'
-            ]);
-        case 'ZodArray':
-        case 'ZodTuple':
-            return new Set([
-                'array'
-            ]);
-        case 'ZodObject':
-        case 'ZodRecord':
-        case 'ZodDiscriminatedUnion':
-            return new Set([
-                'object'
-            ]);
-        case 'ZodLiteral':
-            return new Set([
-                getLiteralValueKind(definition.value)
-            ]);
-        case 'ZodNativeEnum':
-            return new Set(z.util.getValidEnumValues(definition.values ?? {}).map(getLiteralValueKind));
-        case 'ZodUnion':
-            return new Set((definition.options ?? []).flatMap((option)=>[
-                    ...getZodValueKinds(option)
-                ]));
-        default:
-            return new Set([
-                'unknown'
-            ]);
-    }
-}
 function isMidsceneLocatorField(field) {
     const actualField = unwrapZodField(field);
     if (actualField._def?.typeName === 'ZodObject') {
@@ -98,4 +47,4 @@ function getZodDescription(field) {
     if (isMidsceneLocatorField(actualField)) return 'Location information for the target element';
     return null;
 }
-export { getZodDescription, getZodTypeName, getZodValueKinds, isMidsceneLocatorField, unwrapZodField };
+export { getZodDescription, getZodTypeName, isMidsceneLocatorField, unwrapZodField };

package/dist/lib/cli/cli-args.js

@@ -27,21 +27,14 @@ __webpack_require__.d(__webpack_exports__, {
     canonicalizeCliArgKeys: ()=>canonicalizeCliArgKeys,
     parseCliArgs: ()=>parseCliArgs,
     formatCliValidationError: ()=>formatCliValidationError,
-    parseValue: ()=>parseValue,
+    parseValue: ()=>external_cli_value_js_namespaceObject.parseValue,
     getCliOptionDisplay: ()=>getCliOptionDisplay
 });
 const external_zod_namespaceObject = require("zod");
 const external_key_alias_utils_js_namespaceObject = require("../key-alias-utils.js");
-const external_zod_schema_utils_js_namespaceObject = require("../zod-schema-utils.js");
 const external_cli_error_js_namespaceObject = require("./cli-error.js");
-const cliNumberPattern = /^-?\d+(\.\d+)?$/;
-function parseValue(raw) {
-    const parsedJson = parseJsonValue(raw);
-    if (parsedJson !== raw) return parsedJson;
-    if (cliNumberPattern.test(raw)) return Number(raw);
-    return raw;
-}
-function walkCliArgs(args, setArgValue, fieldByCliName) {
+const external_cli_value_js_namespaceObject = require("./cli-value.js");
+function walkCliArgs(args, setArgValue) {
     for(let i = 0; i < args.length; i++){
         const arg = args[i];
         if (!arg.startsWith('--')) continue;
@@ -49,10 +42,10 @@ function walkCliArgs(args, setArgValue, fieldByCliName) {
         const eqIdx = body.indexOf('=');
         if (eqIdx >= 0) {
             const key = body.slice(0, eqIdx);
-            setArgValue(key, parseCliValue(body.slice(eqIdx + 1), fieldByCliName?.get(key)));
+            setArgValue(key, body.slice(eqIdx + 1));
         } else if (args[i + 1] && !args[i + 1].startsWith('--')) {
             i++;
-            setArgValue(body, parseCliValue(args[i], fieldByCliName?.get(body)));
+            setArgValue(body, args[i]);
         } else setArgValue(body, true);
     }
 }
@@ -61,48 +54,29 @@ function buildCliFieldIndex(def) {
     for (const [schemaKey, field] of Object.entries(def.schema))for (const cliName of getAcceptedCliOptionNames(schemaKey, def.cli?.options?.[schemaKey]))fieldByCliName.set(cliName, field);
     return fieldByCliName;
 }
-function parseJsonValue(raw) {
-    if (!raw.startsWith('{') && !raw.startsWith('[')) return raw;
-    try {
-        return JSON.parse(raw);
-    } catch  {
-        return raw;
-    }
-}
-function parseCliValue(raw, field) {
-    if (!field) return parseValue(raw);
-    const kinds = (0, external_zod_schema_utils_js_namespaceObject.getZodValueKinds)(field);
-    if (kinds.has('object') || kinds.has('array')) {
-        const parsedJson = parseJsonValue(raw);
-        if (parsedJson !== raw) return parsedJson;
-    }
-    if (kinds.has('string')) return raw;
-    if (kinds.has('number') && cliNumberPattern.test(raw)) return Number(raw);
-    if (kinds.has('boolean')) {
-        if ('true' === raw) return true;
-        if ('false' === raw) return false;
-    }
-    return kinds.has('unknown') ? parseValue(raw) : raw;
-}
 function parseCliArgs(args, def) {
-    const result = {};
     const fieldByCliName = def ? buildCliFieldIndex(def) : void 0;
-    walkCliArgs(args, (key, value)=>{
-        const existing = result[key];
-        if (void 0 === existing) {
-            result[key] = value;
-            return;
-        }
-        if (Array.isArray(existing)) {
-            existing.push(value);
-            result[key] = existing;
-            return;
+    const tokensByName = new Map();
+    walkCliArgs(args, (key, raw)=>{
+        const tokens = tokensByName.get(key) ?? [];
+        tokens.push(raw);
+        tokensByName.set(key, tokens);
+    });
+    const result = {};
+    for (const [key, tokens] of tokensByName){
+        let elementIndex = 0;
+        for (const raw of tokens){
+            const existing = result[key];
+            const value = true === raw ? true : (0, external_cli_value_js_namespaceObject.parseCliValue)(raw, fieldByCliName?.get(key), tokens.length > 1 ? elementIndex : void 0);
+            if (void 0 === existing) result[key] = value;
+            else if (Array.isArray(existing)) existing.push(value);
+            else result[key] = [
+                existing,
+                value
+            ];
+            elementIndex = Array.isArray(result[key]) ? result[key].length : 1;
         }
-        result[key] = [
-            existing,
-            value
-        ];
-    }, fieldByCliName);
+    }
     return result;
 }
 function formatCliOptionName(name) {

package/dist/lib/cli/cli-value.js

@@ -0,0 +1,124 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    parseValue: ()=>parseValue,
+    parseCliValue: ()=>parseCliValue
+});
+const external_zod_namespaceObject = require("zod");
+const external_zod_schema_utils_js_namespaceObject = require("../zod-schema-utils.js");
+const cliNumberPattern = /^-?\d+(\.\d+)?$/;
+function getFieldDef(field) {
+    return field._def;
+}
+function getFieldKind(field) {
+    return getFieldDef(field).typeName;
+}
+function parseJsonValue(raw) {
+    if (!raw.startsWith('{') && !raw.startsWith('[')) return raw;
+    try {
+        return JSON.parse(raw);
+    } catch  {
+        return raw;
+    }
+}
+function parseValue(raw) {
+    const parsed = parseJsonValue(raw);
+    if (parsed !== raw) return parsed;
+    return cliNumberPattern.test(raw) ? Number(raw) : raw;
+}
+function getInputFields(field) {
+    const input = (0, external_zod_schema_utils_js_namespaceObject.unwrapZodField)(field);
+    const inputDef = getFieldDef(input);
+    if (inputDef.typeName === external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodUnion) return (inputDef.options ?? []).flatMap(getInputFields);
+    return [
+        input
+    ];
+}
+function getRepeatedInputFields(fields, index) {
+    const collections = fields.filter((field)=>{
+        const kind = getFieldKind(field);
+        return kind === external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodArray || kind === external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodTuple;
+    });
+    if (0 === collections.length) return fields;
+    return collections.flatMap((field)=>{
+        const fieldDef = getFieldDef(field);
+        const item = fieldDef.typeName === external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodArray ? fieldDef.type : fieldDef.items?.[index] ?? fieldDef.rest;
+        return item ? getInputFields(item) : [];
+    });
+}
+function acceptsValue(field, value) {
+    switch(getFieldKind(field)){
+        case external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodString:
+            return 'string' == typeof value && field.safeParse(value).success;
+        case external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodNumber:
+            return 'number' == typeof value && field.safeParse(value).success;
+        case external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodBoolean:
+            return 'boolean' == typeof value;
+        case external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodEnum:
+        case external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodNativeEnum:
+        case external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodLiteral:
+            return field.safeParse(value).success;
+        case external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodArray:
+        case external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodTuple:
+            return Array.isArray(value);
+        case external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodObject:
+        case external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodRecord:
+        case external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+            return 'object' == typeof value && null !== value && !Array.isArray(value);
+        default:
+            return;
+    }
+}
+function usesLegacyInference(field) {
+    const kind = getFieldKind(field);
+    return kind === external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodAny || kind === external_zod_namespaceObject.z.ZodFirstPartyTypeKind.ZodUnknown;
+}
+function parseCliValue(raw, field, index) {
+    if (!field) return parseValue(raw);
+    const json = parseJsonValue(raw);
+    const wholeFields = getInputFields(field);
+    if (json !== raw && wholeFields.some((input)=>acceptsValue(input, json))) return json;
+    const fields = void 0 === index ? wholeFields : getRepeatedInputFields(wholeFields, index);
+    const candidates = json !== raw ? [
+        json,
+        raw
+    ] : [
+        raw
+    ];
+    if (cliNumberPattern.test(raw)) candidates.push(Number(raw));
+    if ('true' === raw || 'false' === raw) candidates.push('true' === raw);
+    for (const candidate of candidates)if (fields.some((input)=>acceptsValue(input, candidate))) return candidate;
+    return fields.some(usesLegacyInference) ? parseValue(raw) : raw;
+}
+exports.parseCliValue = __webpack_exports__.parseCliValue;
+exports.parseValue = __webpack_exports__.parseValue;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "parseCliValue",
+    "parseValue"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/env/parse-model-config.js

@@ -37,7 +37,7 @@ const external_utils_js_namespaceObject = require("../utils.js");
 const external_helper_js_namespaceObject = require("./helper.js");
 const external_init_debug_js_namespaceObject = require("./init-debug.js");
 const MODEL_CONFIG_DOC_URL = 'https://midscenejs.com/model-common-config.html';
-const getCurrentVersion = ()=>"1.12.7-beta-20260914023554.0";
+const getCurrentVersion = ()=>"1.12.7";
 const getInvalidModelFamilyMessage = (modelFamily)=>`Invalid MIDSCENE_MODEL_FAMILY value: ${modelFamily}. Current version v${getCurrentVersion()} accepts the following model families: ${external_types_js_namespaceObject.MODEL_FAMILY_VALUES.join(', ')}. You can also visit ${MODEL_CONFIG_DOC_URL} for the latest configuration information.`;
 const KEYS_MAP = {
     insight: external_constants_js_namespaceObject.INSIGHT_MODEL_CONFIG_KEYS,

package/dist/lib/zod-schema-utils.js

@@ -24,13 +24,11 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    getZodTypeName: ()=>getZodTypeName,
     getZodDescription: ()=>getZodDescription,
-    getZodValueKinds: ()=>getZodValueKinds,
+    getZodTypeName: ()=>getZodTypeName,
     isMidsceneLocatorField: ()=>isMidsceneLocatorField,
     unwrapZodField: ()=>unwrapZodField
 });
-const external_zod_namespaceObject = require("zod");
 function unwrapZodField(field) {
     const f = field;
     if (!f._def) return f;
@@ -41,56 +39,6 @@ function unwrapZodField(field) {
     }
     return f;
 }
-function getLiteralValueKind(value) {
-    if ('string' == typeof value) return 'string';
-    if ('number' == typeof value) return 'number';
-    if ('boolean' == typeof value) return 'boolean';
-    return 'unknown';
-}
-function getZodValueKinds(field) {
-    const actualField = unwrapZodField(field);
-    const definition = actualField._def;
-    switch(definition?.typeName){
-        case 'ZodString':
-        case 'ZodEnum':
-            return new Set([
-                'string'
-            ]);
-        case 'ZodNumber':
-            return new Set([
-                'number'
-            ]);
-        case 'ZodBoolean':
-            return new Set([
-                'boolean'
-            ]);
-        case 'ZodArray':
-        case 'ZodTuple':
-            return new Set([
-                'array'
-            ]);
-        case 'ZodObject':
-        case 'ZodRecord':
-        case 'ZodDiscriminatedUnion':
-            return new Set([
-                'object'
-            ]);
-        case 'ZodLiteral':
-            return new Set([
-                getLiteralValueKind(definition.value)
-            ]);
-        case 'ZodNativeEnum':
-            return new Set(external_zod_namespaceObject.z.util.getValidEnumValues(definition.values ?? {}).map(getLiteralValueKind));
-        case 'ZodUnion':
-            return new Set((definition.options ?? []).flatMap((option)=>[
-                    ...getZodValueKinds(option)
-                ]));
-        default:
-            return new Set([
-                'unknown'
-            ]);
-    }
-}
 function isMidsceneLocatorField(field) {
     const actualField = unwrapZodField(field);
     if (actualField._def?.typeName === 'ZodObject') {
@@ -132,13 +80,11 @@ function getZodDescription(field) {
 }
 exports.getZodDescription = __webpack_exports__.getZodDescription;
 exports.getZodTypeName = __webpack_exports__.getZodTypeName;
-exports.getZodValueKinds = __webpack_exports__.getZodValueKinds;
 exports.isMidsceneLocatorField = __webpack_exports__.isMidsceneLocatorField;
 exports.unwrapZodField = __webpack_exports__.unwrapZodField;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getZodDescription",
     "getZodTypeName",
-    "getZodValueKinds",
     "isMidsceneLocatorField",
     "unwrapZodField"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/types/cli/cli-args.d.ts

@@ -1,5 +1,5 @@
 import type { ToolCliOption, ToolDefinition } from '../agent-tools/types';
-export declare function parseValue(raw: string): unknown;
+export { parseValue } from './cli-value';
 export declare function parseCliArgs(args: string[], def?: ToolDefinition): Record<string, unknown>;
 export declare function getCliOptionDisplay(key: string, cliOption?: ToolCliOption): {
     label: string;

package/dist/types/cli/cli-value.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export declare function parseValue(raw: string): unknown;
+/** Decode one CLI token; index is supplied only for repeated options. */
+export declare function parseCliValue(raw: string, field?: z.ZodTypeAny, index?: number): unknown;

package/dist/types/zod-schema-utils.d.ts

@@ -1,17 +1,9 @@
-import { z } from 'zod';
-export type ZodValueKind = 'string' | 'number' | 'boolean' | 'array' | 'object' | 'unknown';
+import type { z } from 'zod';
 /**
  * Recursively unwrap optional, nullable, default, and effects wrapper types
  * to get the actual inner Zod type
  */
 export declare function unwrapZodField(field: unknown): unknown;
-/**
- * Classify the supported top-level Zod input kinds without running validation.
- * Unrecognized types return `unknown`; refinements are not evaluated. Unlike
- * `getZodTypeName`, this normalizes enums, literals, and unions so consumers
- * can make type-directed decisions without parsing its display label.
- */
-export declare function getZodValueKinds(field: unknown): Set<ZodValueKind>;
 /**
  * Check if a field is a Midscene locator field
  * Locator input schemas are identified by their prompt field.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midscene/shared",
-  "version": "1.12.7-beta-20260914023554.0",
+  "version": "1.12.7",
   "repository": "https://github.com/web-infra-dev/midscene",
   "homepage": "https://midscenejs.com/",
   "types": "./dist/types/index.d.ts",

package/src/cli/cli-args.ts

@@ -1,26 +1,13 @@
 import { z } from 'zod';
 import type { ToolCliOption, ToolDefinition } from '../agent-tools/types';
 import { getKeyAliases } from '../key-alias-utils';
-import { getZodValueKinds } from '../zod-schema-utils';
 import { CLIError } from './cli-error';
-
-const cliNumberPattern = /^-?\d+(\.\d+)?$/;
-
-export function parseValue(raw: string): unknown {
-  const parsedJson = parseJsonValue(raw);
-  if (parsedJson !== raw) return parsedJson;
-
-  if (cliNumberPattern.test(raw)) {
-    return Number(raw);
-  }
-
-  return raw;
-}
+import { parseCliValue } from './cli-value';
+export { parseValue } from './cli-value';
 
 function walkCliArgs(
   args: string[],
-  setArgValue: (key: string, value: unknown) => void,
-  fieldByCliName?: ReadonlyMap<string, z.ZodTypeAny>,
+  setArgValue: (key: string, value: string | true) => void,
 ): void {
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -31,13 +18,10 @@ function walkCliArgs(
 
     if (eqIdx >= 0) {
       const key = body.slice(0, eqIdx);
-      setArgValue(
-        key,
-        parseCliValue(body.slice(eqIdx + 1), fieldByCliName?.get(key)),
-      );
+      setArgValue(key, body.slice(eqIdx + 1));
     } else if (args[i + 1] && !args[i + 1].startsWith('--')) {
       i++;
-      setArgValue(body, parseCliValue(args[i], fieldByCliName?.get(body)));
+      setArgValue(body, args[i]);
     } else {
       setArgValue(body, true);
     }
@@ -61,68 +45,41 @@ function buildCliFieldIndex(
   return fieldByCliName;
 }
 
-function parseJsonValue(raw: string): unknown {
-  if (!raw.startsWith('{') && !raw.startsWith('[')) return raw;
-
-  try {
-    return JSON.parse(raw);
-  } catch {
-    // Preserve malformed JSON for string fields or the later schema error.
-    return raw;
-  }
-}
-
-function parseCliValue(raw: string, field?: z.ZodTypeAny): unknown {
-  if (!field) return parseValue(raw);
-
-  const kinds = getZodValueKinds(field);
-  if (kinds.has('object') || kinds.has('array')) {
-    const parsedJson = parseJsonValue(raw);
-    if (parsedJson !== raw) return parsedJson;
-  }
-
-  // CLI input cannot distinguish a numeric-looking identifier from a number.
-  // Prefer the lossless representation whenever the schema accepts strings.
-  if (kinds.has('string')) return raw;
-
-  if (kinds.has('number') && cliNumberPattern.test(raw)) {
-    return Number(raw);
-  }
-
-  if (kinds.has('boolean')) {
-    if (raw === 'true') return true;
-    if (raw === 'false') return false;
-  }
-
-  return kinds.has('unknown') ? parseValue(raw) : raw;
-}
-
 export function parseCliArgs(
   args: string[],
   def?: ToolDefinition,
 ): Record<string, unknown> {
-  const result: Record<string, unknown> = {};
   const fieldByCliName = def ? buildCliFieldIndex(def) : undefined;
+  const tokensByName = new Map<string, Array<string | true>>();
+  walkCliArgs(args, (key, raw) => {
+    const tokens = tokensByName.get(key) ?? [];
+    tokens.push(raw);
+    tokensByName.set(key, tokens);
+  });
 
-  walkCliArgs(
-    args,
-    (key, value) => {
+  const result: Record<string, unknown> = {};
+  for (const [key, tokens] of tokensByName) {
+    let elementIndex = 0;
+    for (const raw of tokens) {
       const existing = result[key];
+      const value =
+        raw === true
+          ? true
+          : parseCliValue(
+              raw,
+              fieldByCliName?.get(key),
+              tokens.length > 1 ? elementIndex : undefined,
+            );
       if (existing === undefined) {
         result[key] = value;
-        return;
-      }
-
-      if (Array.isArray(existing)) {
+      } else if (Array.isArray(existing)) {
         existing.push(value);
-        result[key] = existing;
-        return;
+      } else {
+        result[key] = [existing, value];
       }
-
-      result[key] = [existing, value];
-    },
-    fieldByCliName,
-  );
+      elementIndex = Array.isArray(result[key]) ? result[key].length : 1;
+    }
+  }
 
   return result;
 }

package/src/cli/cli-value.ts

@@ -0,0 +1,137 @@
+import { z } from 'zod';
+import { unwrapZodField } from '../zod-schema-utils';
+
+const cliNumberPattern = /^-?\d+(\.\d+)?$/;
+
+interface CliZodDef {
+  typeName?: z.ZodFirstPartyTypeKind;
+  options?: z.ZodTypeAny[];
+  type?: z.ZodTypeAny;
+  items?: z.ZodTypeAny[];
+  rest?: z.ZodTypeAny | null;
+}
+
+function getFieldDef(field: z.ZodTypeAny): CliZodDef {
+  return (field as z.ZodTypeAny & { _def: CliZodDef })._def;
+}
+
+function getFieldKind(
+  field: z.ZodTypeAny,
+): z.ZodFirstPartyTypeKind | undefined {
+  return getFieldDef(field).typeName;
+}
+
+function parseJsonValue(raw: string): unknown {
+  if (!raw.startsWith('{') && !raw.startsWith('[')) return raw;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    // Preserve text for string inputs or the later schema validation error.
+    return raw;
+  }
+}
+
+export function parseValue(raw: string): unknown {
+  const parsed = parseJsonValue(raw);
+  if (parsed !== raw) return parsed;
+  return cliNumberPattern.test(raw) ? Number(raw) : raw;
+}
+
+// Keep the actual alternatives: a string literal is not an arbitrary string,
+// and a repeated tuple argument must retain its position-specific schema.
+function getInputFields(field: z.ZodTypeAny): z.ZodTypeAny[] {
+  const input = unwrapZodField(field) as z.ZodTypeAny;
+  const inputDef = getFieldDef(input);
+  if (inputDef.typeName === z.ZodFirstPartyTypeKind.ZodUnion) {
+    return (inputDef.options ?? []).flatMap(getInputFields);
+  }
+  return [input];
+}
+
+function getRepeatedInputFields(
+  fields: z.ZodTypeAny[],
+  index: number,
+): z.ZodTypeAny[] {
+  const collections = fields.filter((field) => {
+    const kind = getFieldKind(field);
+    return (
+      kind === z.ZodFirstPartyTypeKind.ZodArray ||
+      kind === z.ZodFirstPartyTypeKind.ZodTuple
+    );
+  });
+  if (collections.length === 0) return fields;
+  return collections.flatMap((field) => {
+    const fieldDef = getFieldDef(field);
+    const item =
+      fieldDef.typeName === z.ZodFirstPartyTypeKind.ZodArray
+        ? fieldDef.type
+        : (fieldDef.items?.[index] ?? fieldDef.rest);
+    return item ? getInputFields(item) : [];
+  });
+}
+
+// Only inspect scalar constraints here. Effects have been unwrapped, and
+// collection children are left to the existing full validation step.
+function acceptsValue(
+  field: z.ZodTypeAny,
+  value: unknown,
+): boolean | undefined {
+  switch (getFieldKind(field)) {
+    case z.ZodFirstPartyTypeKind.ZodString:
+      return typeof value === 'string' && field.safeParse(value).success;
+    case z.ZodFirstPartyTypeKind.ZodNumber:
+      return typeof value === 'number' && field.safeParse(value).success;
+    case z.ZodFirstPartyTypeKind.ZodBoolean:
+      return typeof value === 'boolean';
+    case z.ZodFirstPartyTypeKind.ZodEnum:
+    case z.ZodFirstPartyTypeKind.ZodNativeEnum:
+    case z.ZodFirstPartyTypeKind.ZodLiteral:
+      return field.safeParse(value).success;
+    case z.ZodFirstPartyTypeKind.ZodArray:
+    case z.ZodFirstPartyTypeKind.ZodTuple:
+      return Array.isArray(value);
+    case z.ZodFirstPartyTypeKind.ZodObject:
+    case z.ZodFirstPartyTypeKind.ZodRecord:
+    case z.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+      return (
+        typeof value === 'object' && value !== null && !Array.isArray(value)
+      );
+    default:
+      return undefined;
+  }
+}
+
+function usesLegacyInference(field: z.ZodTypeAny): boolean {
+  const kind = getFieldKind(field);
+  return (
+    kind === z.ZodFirstPartyTypeKind.ZodAny ||
+    kind === z.ZodFirstPartyTypeKind.ZodUnknown
+  );
+}
+
+/** Decode one CLI token; index is supplied only for repeated options. */
+export function parseCliValue(
+  raw: string,
+  field?: z.ZodTypeAny,
+  index?: number,
+): unknown {
+  if (!field) return parseValue(raw);
+  const json = parseJsonValue(raw);
+  const wholeFields = getInputFields(field);
+  if (json !== raw && wholeFields.some((input) => acceptsValue(input, json))) {
+    return json;
+  }
+
+  const fields =
+    index === undefined
+      ? wholeFields
+      : getRepeatedInputFields(wholeFields, index);
+  const candidates: unknown[] = json !== raw ? [json, raw] : [raw];
+  if (cliNumberPattern.test(raw)) candidates.push(Number(raw));
+  if (raw === 'true' || raw === 'false') candidates.push(raw === 'true');
+  for (const candidate of candidates) {
+    if (fields.some((input) => acceptsValue(input, candidate)))
+      return candidate;
+  }
+  return fields.some(usesLegacyInference) ? parseValue(raw) : raw;
+}

package/src/zod-schema-utils.ts

@@ -1,12 +1,4 @@
-import { z } from 'zod';
-
-export type ZodValueKind =
-  | 'string'
-  | 'number'
-  | 'boolean'
-  | 'array'
-  | 'object'
-  | 'unknown';
+import type { z } from 'zod';
 
 /**
  * Recursively unwrap optional, nullable, default, and effects wrapper types
@@ -39,64 +31,6 @@ export function unwrapZodField(field: unknown): unknown {
   return f;
 }
 
-function getLiteralValueKind(value: unknown): ZodValueKind {
-  if (typeof value === 'string') return 'string';
-  if (typeof value === 'number') return 'number';
-  if (typeof value === 'boolean') return 'boolean';
-  return 'unknown';
-}
-
-/**
- * Classify the supported top-level Zod input kinds without running validation.
- * Unrecognized types return `unknown`; refinements are not evaluated. Unlike
- * `getZodTypeName`, this normalizes enums, literals, and unions so consumers
- * can make type-directed decisions without parsing its display label.
- */
-export function getZodValueKinds(field: unknown): Set<ZodValueKind> {
-  const actualField = unwrapZodField(field) as {
-    _def?: {
-      typeName?: string;
-      options?: unknown[];
-      value?: unknown;
-      values?: Record<string, unknown>;
-    };
-  };
-  const definition = actualField._def;
-
-  switch (definition?.typeName) {
-    case 'ZodString':
-    case 'ZodEnum':
-      return new Set(['string']);
-    case 'ZodNumber':
-      return new Set(['number']);
-    case 'ZodBoolean':
-      return new Set(['boolean']);
-    case 'ZodArray':
-    case 'ZodTuple':
-      return new Set(['array']);
-    case 'ZodObject':
-    case 'ZodRecord':
-    case 'ZodDiscriminatedUnion':
-      return new Set(['object']);
-    case 'ZodLiteral':
-      return new Set([getLiteralValueKind(definition.value)]);
-    case 'ZodNativeEnum':
-      return new Set(
-        z.util
-          .getValidEnumValues(definition.values ?? {})
-          .map(getLiteralValueKind),
-      );
-    case 'ZodUnion':
-      return new Set(
-        (definition.options ?? []).flatMap((option) => [
-          ...getZodValueKinds(option),
-        ]),
-      );
-    default:
-      return new Set(['unknown']);
-  }
-}
-
 /**
  * Check if a field is a Midscene locator field
  * Locator input schemas are identified by their prompt field.