@arcteninc/core 0.0.44 → 0.0.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcteninc/core",
-  "version": "0.0.44",
+  "version": "0.0.45",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",

package/scripts/cli-extract-types-auto.ts

@@ -698,9 +698,10 @@ function isFallbackAnySchema(
   type: ts.Type,
   checker: ts.TypeChecker
 ): boolean {
-  // If it's not 'any', it's a real schema
-  if (schema.type !== 'any') {
-    return false;
+  // Empty schema {} means "any value" in JSON Schema draft 2020-12
+  // If schema is empty (no keys), it's a fallback "any" schema
+  if (Object.keys(schema).length === 0) {
+    return true;
   }
   
   // If it has properties, anyOf, or items, it's a real schema
@@ -708,6 +709,11 @@ function isFallbackAnySchema(
     return false;
   }
   
+  // If it has a type property (and it's not 'any'), it's a real schema
+  if (schema.type && schema.type !== 'any') {
+    return false;
+  }
+  
   // Check if it's actually a type reference we couldn't resolve
   // (not a primitive, not an object we processed, etc.)
   return isTypeReference(type, checker);
@@ -754,12 +760,12 @@ function serializeType(
   const typeString = checker.typeToString(type);
   
   if (depth > MAX_SERIALIZATION_DEPTH) {
-    return { isOptional: false, schema: { type: 'any' } };
+    return { isOptional: false, schema: {} }; // Empty schema = any value (JSON Schema draft 2020-12)
   }
 
   const typeId = getTypeId(type);
   if (typeId !== undefined && visited.has(typeId)) {
-    return { isOptional: false, schema: { type: 'any' } };
+    return { isOptional: false, schema: {} }; // Empty schema = any value (JSON Schema draft 2020-12)
   }
 
   // Handle primitives
@@ -877,21 +883,21 @@ function serializeType(
                   if (!isFallbackAnySchema(resolvedResult.schema, resolvedType, checker)) {
                     anyOf.push(resolvedResult.schema);
                   } else {
-                    anyOf.push({ type: 'any' });
+                    anyOf.push({}); // Empty schema = any value (JSON Schema draft 2020-12)
                   }
                 } catch (error) {
-                  anyOf.push({ type: 'any' });
+                  anyOf.push({}); // Empty schema = any value (JSON Schema draft 2020-12)
                 }
               } else {
-                // It's a type reference we couldn't fully resolve - use 'any'
-                anyOf.push({ type: 'any' });
+                // It's a type reference we couldn't fully resolve - use empty schema (any value)
+                anyOf.push({}); // Empty schema = any value (JSON Schema draft 2020-12)
               }
             }
           } catch (error) {
             // Fallback for unresolvable types
             const unionTypeString = checker.typeToString(unionType);
             console.warn(`Warning: Could not serialize union type: ${unionTypeString}`, error);
-            anyOf.push({ type: 'any' });
+            anyOf.push({}); // Empty schema = any value (JSON Schema draft 2020-12)
           }
         }
       }
@@ -921,7 +927,7 @@ function serializeType(
     // Fallback
     return {
       isOptional: false,
-      schema: { type: 'any' }
+      schema: {} // Empty schema = any value (JSON Schema draft 2020-12)
     };
   }
 
@@ -1080,8 +1086,8 @@ function serializeType(
     } catch (error) {
       console.warn(`Warning: Could not extract enum values for type: ${typeString}`, error);
     }
-    // If we can't extract enum values, use 'any'
-    return { isOptional: false, schema: { type: 'any' } };
+    // If we can't extract enum values, use empty schema (any value)
+    return { isOptional: false, schema: {} }; // Empty schema = any value (JSON Schema draft 2020-12)
   }
   
   // Check if it's a type reference (like InternalFilterType.StringFilter)
@@ -1093,7 +1099,7 @@ function serializeType(
       // Empty object or type reference we can't resolve
       // Check if typeString suggests it's a named type reference
       if (typeString && typeString.includes('.')) {
-        return { isOptional: false, schema: { type: 'any' } };
+        return { isOptional: false, schema: {} }; // Empty schema = any value (JSON Schema draft 2020-12)
       }
     }
   }
@@ -1129,17 +1135,18 @@ function serializeType(
     return { isOptional: false, schema: { type: 'null' } };
   }
   if (type.flags & ts.TypeFlags.Unknown) {
-    return { isOptional: false, schema: { type: 'any' } };
+    return { isOptional: false, schema: {} }; // Empty schema = any value (JSON Schema draft 2020-12)
   }
   if (type.flags & ts.TypeFlags.Any) {
-    return { isOptional: false, schema: { type: 'any' } };
+    return { isOptional: false, schema: {} }; // Empty schema = any value (JSON Schema draft 2020-12)
   }
 
-  // For any other unrecognized type, use 'any' instead of invalid type strings
+  // For any other unrecognized type, use empty schema instead of invalid type strings
   // This prevents errors like "type": "InternalFilterType.StringFilter"
+  // Empty schema {} means "allow any value" in JSON Schema draft 2020-12
   return {
     isOptional: false,
-    schema: { type: 'any' }
+    schema: {} // Empty schema = any value (JSON Schema draft 2020-12)
   };
 }
 
@@ -1337,7 +1344,7 @@ function extractFunctionMetadata(
       propSchema = result.schema;
       isOptional = result.isOptional;
     } else {
-      propSchema = { type: 'any' };
+      propSchema = {}; // Empty schema = any value (JSON Schema draft 2020-12)
     }
 
     // Check if parameter has default value or question mark